{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Q-Network Variant Dueling DQN implementation (PyTorch).\n",
    "\n",
    "In this notebook, we will implement Dueling DQN variant of DQN. First part of the notebook is all about the vanilla DQN and how we train - a copy of `6.a-dqn_pytorch.ipynb`. The Dueling DQN variant is after these sections on vanilla DQN. \n",
    "\n",
    "\n",
    "\n",
    "### RECAP\n",
    "\n",
    "Q Learning control is carried out by sampling step by step and updating Q values at each step. We use $\\epsilon$-greedy policy to explore and generate samples. However, the policy learnt is a deterministic greedy policy with no exploration. We can carryout updates online i.e. we take a step and use `(current state, action, reward and next_state)` tuple to update.\n",
    "\n",
    "In case of function approximation using neural network, the input to the network is the state and output is the $q(s,a)$ for all the actions in the state $s$. It is denoted as $ \\hat{q}(s_t, a_t; w_{t}) $, where $w_{t}$ is the weigths of the neural network that we learn as part of DQN learning.\n",
    "\n",
    "We use two networks, one target network with weight $w^-_t$ to get the max $q$-value of next state with best action denoted by $ \\max\\limits_a \\hat {q}(S_{t+1},a; w^{-}_{t}) $ and network with weights $w_t^-$ which we periodically updated from primary network $w_t$.\n",
    "\n",
    "The Update equation is given below. This is the online version:\n",
    "$$ w_{t+1} \\leftarrow w_t + \\alpha [ R_{t+1} + \\gamma . \\max_{a} \\hat{q}(S_{t+1},a;w^{-}_{t}) – \\hat{q}(S_t,A_t;w_t)] \\nabla_{w_t} \\hat{q}(S_t,A_t;w_t)$$\n",
    "\n",
    "Online update with neural network with millions of weights does not work well. Accordingly, We use experience replay (aka Replay Buffer).  We use a behavior policy to explore the environment and store the samples `(s, a, r, s', done)` in a buffer. The samples are generated using an exploratory behavior policy while we improve a deterministic target policy using q-values.\n",
    "\n",
    "Therefore, we can always use older samples from behavior policy and apply them again and again. We can keep the buffer size fixed to some pre-determined size and keep deleting the older samples as we collect new ones. This process makes learning sample efficient by reusing a sample multiple times and also removing temporal dependence of the samples we would otherwise see while following a trajectory.\n",
    "\n",
    "The update equation with batch update with minor modifications is given below. We collect samples of transitions `(current state, action, reward, next state)` in a buffer, where each sample is denoted as a tuple:\n",
    "\n",
    "$$ (s_{i}, a_{i}, r_{i}, s'_{i}, done_{i})$$\n",
    "\n",
    "Subscript ($i$) denotes ith sample. We take $N$ samples from experience replay selecting randomly and update the weights. Subscript ($t$) denotes the index of weight updates. If the current state is done, as denoted by `done` flag, the target is just the reward as terminal states have zero value. The final update equation is as given below:\n",
    "\n",
    "$$w_{t+1} \\leftarrow w_t + \\alpha \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_{i},a';w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla_{w_t} \\hat{q}(s_i,a_i;w_t)$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Running in Colab/Kaggle\n",
    "\n",
    "If you are running this on Colab, please uncomment below cells and run this to install required dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Uncomment and execute this cell to install all the the dependencies if running in Google Colab\n",
    "\n",
    "# !apt-get update && apt-get install swig cmake ffmpeg freeglut3-dev xvfb\n",
    "# !pip install box2d-py\n",
    "# !pip install \"stable-baselines3[extra]>=2.1\"\n",
    "# !pip install \"huggingface_sb3>=3.0\"\n",
    "\n",
    "# !pip install git+https://github.com/DLR-RM/rl-baselines3-zoo@update/hf\n",
    "# !git clone https://github.com/DLR-RM/rl-baselines3-zoo\n",
    "# %cd rl-baselines3-zoo/\n",
    "# !pip install -r requirements.txt\n",
    "# %cd .."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import convolve, gaussian\n",
    "from stable_baselines3.common.vec_env import VecVideoRecorder, DummyVecEnv\n",
    "from base64 import b64encode\n",
    "\n",
    "from IPython.display import HTML\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - CartPole \n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are discrete. We will build it on Cart Pole. Readers can try to run this on many other environments like Lunar Lander and others."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name):\n",
    "    # increase time limit from 200/500 to 4000\n",
    "    env = gym.make(env_name, render_mode=\"rgb_array\", max_episode_steps=4000)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state shape:(4,)\n",
      "Number of Actions:2\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "env_name = 'CartPole-v1'\n",
    "seed=123\n",
    "\n",
    "env = make_env(env_name)\n",
    "env.reset(seed=seed)\n",
    "plt.imshow(env.render())\n",
    "state_shape, n_actions = env.observation_space.shape, env.action_space.n\n",
    "print(f\"state shape:{state_shape}\\nNumber of Actions:{n_actions}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a network using pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us build a DQN agent using a simple network. We now need to build a neural network that can map states/observations to state q-values. The observation space and action space is as given below for CartPole\n",
    "\n",
    "    Observation:\n",
    "        Type: Box(4)\n",
    "        Num     Observation               Min                     Max\n",
    "        0       Cart Position             -4.8                    4.8\n",
    "        1       Cart Velocity             -Inf                    Inf\n",
    "        2       Pole Angle                -0.418 rad (-24 deg)    0.418 rad (24 deg)\n",
    "        3       Pole Angular Velocity     -Inf                    Inf\n",
    "    Actions:\n",
    "        Type: Discrete(2)\n",
    "        Num   Action\n",
    "        0     Push cart to the left\n",
    "        1     Push cart to the right\n",
    "        \n",
    "\n",
    "The model will be a simple one with 2 hidden payers with Relu activation and final layer being logits with dimension equation to number of actions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, epsilon=0):\n",
    "\n",
    "        super().__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "\n",
    "        state_dim = state_shape[0]\n",
    "        # a simple NN with state_dim as input vector (input is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.network = nn.Sequential()\n",
    "        self.network.add_module('layer1', nn.Linear(state_dim, 256))\n",
    "        self.network.add_module('relu1', nn.ReLU())\n",
    "        self.network.add_module('layer2', nn.Linear(256, 256))\n",
    "        self.network.add_module('relu2', nn.ReLU())\n",
    "        self.network.add_module('layer3', nn.Linear(256, n_actions))\n",
    "        #\n",
    "        self.parameters = self.network.parameters\n",
    "\n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the network to get Q(s,a)\n",
    "        qvalues = self.network(state_t)\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and output is Qvals as numpy array\n",
    "        states = torch.tensor(np.array(states), device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def get_action(self, states):\n",
    "        states = torch.tensor(np.array(states), device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        return best_actions\n",
    "\n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)\n",
    "\n",
    "    def save(self, path):\n",
    "        print(\"path:\",path)\n",
    "        torch.save(self.network.state_dict(), f\"{path}.zip\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = DQNAgent(state_shape, n_actions, epsilon=0.5).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DQNAgent(\n",
       "  (network): Sequential(\n",
       "    (layer1): Linear(in_features=4, out_features=256, bias=True)\n",
       "    (relu1): ReLU()\n",
       "    (layer2): Linear(in_features=256, out_features=256, bias=True)\n",
       "    (relu2): ReLU()\n",
       "    (layer3): Linear(in_features=256, out_features=2, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(env, agent, n_games=1, greedy=False, t_max=10000):\n",
    "    rewards = []\n",
    "    for _ in range(n_games):\n",
    "        s,_ = env.reset()\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            qvalues = agent.get_qvalues([s])\n",
    "            action = qvalues.argmax(axis=-1)[0] if greedy else agent.sample_actions(qvalues)[0]\n",
    "            s, r, termiated, truncated,_ = env.step(action)\n",
    "            reward += r\n",
    "            if termiated:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15.0\n"
     ]
    }
   ],
   "source": [
    "print(evaluate(env, agent, n_games=1))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experience replay\n",
    "\n",
    "We will use the replay buffer we saw in chapter 4 listings. Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy ($\\epsilon$-greedy) to sample from the environment and store the transitions `(s,a,r,s',done)` into a buffer. These samples are used multiple times in a learning making the process sample efficient.\n",
    "\n",
    "The interface to ReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n",
    "We have modified the implementation a bit to make it more efficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, size):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to hold buffer\n",
    "        self.next_id = 0\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "\n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        if len(self.buffer) < self.size:\n",
    "           self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "\n",
    "    def sample(self, batch_size):\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size)\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        return np.array(states), np.array(actions), np.array(rewards), np.array(next_states), np.array(done_flags)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_and_record(start_state, agent, env, exp_replay, n_steps=1):\n",
    "\n",
    "    s = start_state\n",
    "    sum_rewards = 0\n",
    "\n",
    "    # Play the game for n_steps and record transitions in buffer\n",
    "    for _ in range(n_steps):\n",
    "        qvalues = agent.get_qvalues([s])\n",
    "        a = agent.sample_actions(qvalues)[0]\n",
    "        next_s, r, terminated, truncated, _ = env.step(a)\n",
    "        sum_rewards += r\n",
    "        done = terminated or truncated\n",
    "        exp_replay.add(s, a, r, next_s, done)\n",
    "        if done:\n",
    "            s,_ = env.reset()\n",
    "        else:\n",
    "            s = next_s\n",
    "\n",
    "    return sum_rewards, s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Target network\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_network = DQNAgent(agent.state_shape, agent.n_actions, epsilon=0.5).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning with DQN\n",
    "Here we write a function similar to tabular q-learning. We will calculate average TD error per batch using the equation:\n",
    "\n",
    "$$ L =  \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_i,a';w^-_t) \\right) – \\hat{q}_{w_t}(s_i,a_i;w_t) \\right]^2$$\n",
    "\n",
    "\n",
    "$$ \\nabla_{w_t} L =   - \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_i,a';w^-_t) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}_{w_t}(s_i,a_i;w_t)$$\n",
    "\n",
    "\n",
    "$\\hat{q}(s',a';w^{-})$ is calculated using target network whose weights are held constant and refreshed periodically from the agent learning network.\n",
    "\n",
    "Target is given by following:\n",
    "* non terminal state: $r_i +  \\gamma .  \\max\\limits_{a'} \\hat{q}(s'_i,a';w^-_t)$\n",
    "* terminal state: $ r_i $\n",
    "\n",
    "We then carryout back propagation through the agent network to update the weights using equation below:\n",
    "\n",
    "\n",
    "$$\n",
    "w_{t+1} \\leftarrow w_t - \\alpha . \\nabla_{w_t}L$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def td_loss_dqn(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma=0.99, device=device):\n",
    "\n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.long)\n",
    "    rewards = torch.tensor(rewards, device=device, dtype=torch.float)\n",
    "    next_states = torch.tensor(next_states, device=device, dtype=torch.float)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),device=device,dtype=torch.float)\n",
    "\n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    predicted_qvalues = agent(states)\n",
    "\n",
    "    # compute q-values for all actions in next states\n",
    "    # use target network\n",
    "    predicted_next_qvalues = target_network(next_states)\n",
    "\n",
    "    # select q-values for chosen actions\n",
    "    predicted_qvalues_for_actions = predicted_qvalues[range(\n",
    "        len(actions)), actions]\n",
    "\n",
    "    # compute Qmax(next_states, actions) using predicted next q-values\n",
    "    next_state_values,_ = torch.max(predicted_next_qvalues, dim=1)\n",
    "\n",
    "    # compute \"target q-values\"\n",
    "    target_qvalues_for_actions = rewards + gamma * next_state_values * (1-done_flags)\n",
    "\n",
    "    # mean squared error loss to minimize\n",
    "    loss = torch.mean((predicted_qvalues_for_actions -\n",
    "                       target_qvalues_for_actions.detach()) ** 2)\n",
    "\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def epsilon_schedule(start_eps, end_eps, step, final_step):\n",
    "    return start_eps + (end_eps-start_eps)*min(step, final_step)/final_step\n",
    "\n",
    "def smoothen(values):\n",
    "    kernel = gaussian(100, std=100)\n",
    "    kernel = kernel / np.sum(kernel)\n",
    "    return convolve(values, kernel, 'valid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main Loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now carryout the training on DQN setup above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import trange\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set up Environment and Policy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#setup env and agent and target networks\n",
    "env_name = 'CartPole-v1'\n",
    "env = make_env(env_name)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "state,_ = env.reset(seed=seed)\n",
    "\n",
    "agent = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train agent function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_agent(env, agent, target_network, optimizer, td_loss_fn):\n",
    "    \n",
    "    state, _  = env.reset(seed=seed)\n",
    "    # let us fill experience replay with some samples using full random policy\n",
    "    exp_replay = ReplayBuffer(10**4)\n",
    "    for i in range(100):\n",
    "        play_and_record(state, agent, env, exp_replay, n_steps=10**2)\n",
    "        if len(exp_replay) == 10**4:\n",
    "            break\n",
    "    print('Finished filling buffer with: {} samples'.format(len(exp_replay)))\n",
    "\n",
    "    mean_rw_history = []\n",
    "    td_loss_history = []\n",
    "    state, _ = env.reset(seed=seed)\n",
    "    for step in trange(total_steps + 1):\n",
    "\n",
    "        # reduce exploration as we progress\n",
    "        agent.epsilon = epsilon_schedule(start_epsilon, end_epsilon, step, eps_decay_final_step)\n",
    "\n",
    "        # take timesteps_per_epoch and update experience replay buffer\n",
    "        _, state = play_and_record(state, agent, env, exp_replay, timesteps_per_epoch)\n",
    "\n",
    "        # train by sampling batch_size of data from experience replay\n",
    "        states, actions, rewards, next_states, done_flags = exp_replay.sample(batch_size)\n",
    "\n",
    "\n",
    "        # loss = <compute TD loss>\n",
    "        optimizer.zero_grad()\n",
    "        loss = td_loss_fn(agent, target_network, \n",
    "                          states, actions, rewards, next_states, done_flags,                  \n",
    "                          gamma=0.99,\n",
    "                          device=device)\n",
    "\n",
    "        loss.backward()\n",
    "        grad_norm = nn.utils.clip_grad_norm_(agent.parameters(), max_grad_norm)\n",
    "        optimizer.step()\n",
    "\n",
    "        if step % loss_freq == 0:\n",
    "            td_loss_history.append(loss.data.cpu().item())\n",
    "\n",
    "        if step % refresh_target_network_freq == 0:\n",
    "            # Load agent weights into target_network\n",
    "            target_network.load_state_dict(agent.state_dict())\n",
    "\n",
    "        if step % eval_freq == 0:\n",
    "            # eval the agent\n",
    "            mean_rw_history.append(evaluate(\n",
    "                make_env(env_name), agent, n_games=3, greedy=True, t_max=1000)\n",
    "            )\n",
    "\n",
    "            clear_output(True)\n",
    "            print(\"buffer size = %i, epsilon = %.5f\" %\n",
    "                  (len(exp_replay), agent.epsilon))\n",
    "\n",
    "            plt.figure(figsize=[16, 5])\n",
    "            plt.subplot(1, 2, 1)\n",
    "            plt.title(\"Mean return per episode\")\n",
    "            plt.plot(mean_rw_history)\n",
    "            plt.grid()\n",
    "\n",
    "            assert not np.isnan(td_loss_history[-1])\n",
    "            plt.subplot(1, 2, 2)\n",
    "            plt.title(\"TD loss history (smoothened)\")\n",
    "            plt.plot(smoothen(td_loss_history))\n",
    "            plt.grid()\n",
    "\n",
    "            plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setup Training Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 3 * 10**4\n",
    "\n",
    "# set exploration epsilon \n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup some frequency for logging and updating target network\n",
    "loss_freq = 50\n",
    "refresh_target_network_freq = 100\n",
    "eval_freq = 1000\n",
    "\n",
    "# to clip the gradients\n",
    "max_grad_norm = 5000\n",
    "\n",
    "#set up random numbers\n",
    "seed=0\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed) \n",
    "\n",
    "#init environment\n",
    "env_name = 'CartPole-v1'\n",
    "env = make_env(env_name)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "\n",
    "#init agent, target network and Optimizer\n",
    "agent = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())\n",
    "optimizer = torch.optim.Adam(agent.parameters(), lr=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.05000\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABRAAAAHDCAYAAABceTYWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAADnoElEQVR4nOzdd3gU9dYH8O9sT7LZ9N4JhBR6aKH3jgUUwUKxoYBe5Vou7/UqWC4q9o7lgopYUEBFuvQeek2vJKT3sn3eP3ZnkiU92ZbkfJ7HR7KZnf1tSTJz5hSGZVkWhBBCCCGEEEIIIYQQ0giBrRdACCGEEEIIIYQQQgixXxRAJIQQQgghhBBCCCGENIkCiIQQQgghhBBCCCGEkCZRAJEQQgghhBBCCCGEENIkCiASQgghhBBCCCGEEEKaRAFEQgghhBBCCCGEEEJIkyiASAghhBBCCCGEEEIIaRIFEAkhhBBCCCGEEEIIIU2iACIhhBBCCCGEEEIIIaRJFEAkhBCCjIwMMAyDjRs3WvVxx40bh3Hjxln1MQkhhBDSfgzDYPXq1bZehonFixdDLpe3alt7XH9HZWdnQyaT4fjx47ZeisUwDIMVK1bYehntsnr1ajAMw3+t0WgQFBSEzz77zIarIqTtKIBIiJ3YuHEjGIYBwzA4duxYg++zLIugoCAwDINZs2bZYIXWk5ubi9WrV+PixYu2XgohhBBCiF3ijhtb+u/QoUP8hULuP7FYDE9PT4wYMQL/93//h6ysLFs/Hbu2efNmfPDBB7ZeRpNeffVVDBs2DCNHjrT1UjrkxIkTWL16NcrKymy9FIsSi8VYuXIl3njjDSiVSlsvh5BWE9l6AYQQUzKZDJs3b8aoUaNMbj98+DBu3rwJqVRqo5VZT25uLtasWYPQ0FAMGDDA1svpFkJCQlBbWwuxWGzrpRBCCCGkFb7//nuTr7/77jvs27evwe1RUVGora0FACxYsAAzZsyAXq9HaWkp4uPj8cEHH+DDDz/EN998g/nz51tt/bZSW1sLkahtp8GbN2/G1atX8cwzz1hmUR1QWFiIb7/9Ft9++62tl9JhJ06cwJo1a7B48WK4urraejkWtWTJEvzrX//C5s2b8fDDD9t6OYS0CgUQCbEzM2bMwJYtW/DRRx+ZHNxs3rwZsbGxKCoqsuHq2kev10OtVkMmk9l0HUqlEhKJBAKB/Sdfa7Va6PV6SCQSqzwewzA2f38IIYQQ0noPPvigydenTp3Cvn37GtwOGFqVAMCgQYMafD8zMxNTpkzBokWLEBUVhf79+1tszfbAXo53zHWst2nTJohEIsyePdtMKyPW4OrqiilTpmDjxo0UQCSdhv2fRRPSzSxYsADFxcXYt28ff5tarcavv/6K+++/v9H76PV6fPDBB4iJiYFMJoOPjw+WLl2K0tJSk+1+//13zJw5E/7+/pBKpQgPD8drr70GnU5nst24cePQp08fXL9+HePHj4ejoyMCAgLw9ttvt+o5cD1KfvjhB8TExEAqlWL37t0AgJycHDz88MPw8fGBVCpFTEwM/ve///H3PXToEIYMGQLAcGWOK7XhevOFhoZi8eLFDR7z9l56hw4dAsMw+Omnn/DSSy8hICAAjo6OqKio4Pvk5OTk4K677oJcLoeXlxeee+65Bq9FY0JDQzFr1izs3bsXAwYMgEwmQ3R0NLZu3dpg27KyMjzzzDMICgqCVCpFz5498dZbb0Gv1/PbcGVF77zzDj744AOEh4dDKpXi+vXrza5j06ZNiI2NhYODA9zd3TF//nxkZ2c3eF369OmDc+fOYcSIEXBwcEBYWBi++OILk+0a64GYl5eHJUuWIDAwEFKpFH5+frjzzjv5kxDOZ599xr/P/v7+WL58eaOlJ19++SXCw8Ph4OCAoUOH4ujRo40+L5VKhVdeeQU9e/aEVCpFUFAQXnjhBahUqmZfD0IIIYS0XUhICDZu3Ai1Wt3qY73bXbhwAdOnT4dCoYBcLsfEiRNx6tQpk200Gg3WrFmDXr16QSaTwcPDA6NGjTI55m3tsUdTWnNsd3sPxMrKSjzzzDMIDQ2FVCqFt7c3Jk+ejPPnzwMwHEv99ddfyMzM5I9LQ0ND+fsXFBTgkUcegY+PD2QyGfr3798gG7CpY70zZ87AyckJ//jHPxo8l5s3b0IoFGLt2rXNPuft27dj2LBhDXpAJicnY+7cufD19YVMJkNgYCDmz5+P8vJyk9dixYoV2LJlC6Kjo+Hg4IC4uDhcuXIFALB+/Xr07NkTMpkM48aNa/R92LJlC3886unpiQcffBA5OTkNtjtw4ABGjx4NJycnuLq64s4778SNGzf4769evRrPP/88ACAsLIx/rW9/zO3bt6NPnz78eQR3jlFfS+cbQN25wi+//II33ngDgYGBkMlkmDhxIlJSUhrs8/Tp05g2bRpcXFzg6OiIsWPHNtpz8tixYxgyZAhkMhnCw8Oxfv36BttwJk+ejGPHjqGkpKTJbQixJ5SBSIidCQ0NRVxcHH788UdMnz4dALBr1y6Ul5dj/vz5+OijjxrcZ+nSpdi4cSOWLFmCp59+Gunp6fjkk09w4cIFHD9+nC9L3bhxI+RyOVauXAm5XI4DBw7g5ZdfRkVFBdatW2eyz9LSUkybNg1z5szBvHnz8Ouvv+LFF19E3759+XU158CBA/jll1+wYsUKeHp6IjQ0FPn5+Rg+fDh/sOLl5YVdu3bhkUceQUVFBZ555hlERUXh1Vdfxcsvv4zHH38co0ePBgCMGDGiXa/na6+9BolEgueeew4qlYq/yqvT6TB16lQMGzYM77zzDvbv3493330X4eHhePLJJ1vcb3JyMu677z488cQTWLRoETZs2IB7770Xu3fvxuTJkwEANTU1GDt2LHJycrB06VIEBwfjxIkTWLVqFW7dutWgl86GDRugVCrx+OOPQyqVwt3dvcnHf+ONN/Cf//wH8+bNw6OPPorCwkJ8/PHHGDNmDC5cuGBS9lFaWooZM2Zg3rx5WLBgAX755Rc8+eSTkEgkzV7xnDt3Lq5du4annnoKoaGhKCgowL59+5CVlcUfOK9evRpr1qzBpEmT8OSTTyIxMRGff/454uPjTT5733zzDZYuXYoRI0bgmWeeQVpaGu644w64u7sjKCiIf0y9Xo877rgDx44dw+OPP46oqChcuXIF77//PpKSkrB9+/YW3xtCCCGEtE1cXBzCw8NNgnmtde3aNYwePRoKhQIvvPACxGIx1q9fj3HjxuHw4cMYNmwYAMMxw9q1a/Hoo49i6NChqKiowNmzZ3H+/Hn+2Kk1xx5Nae+x3RNPPIFff/0VK1asQHR0NIqLi3Hs2DHcuHEDgwYNwr///W+Ul5fj5s2beP/99wGAD9bV1tZi3LhxSElJwYoVKxAWFoYtW7Zg8eLFKCsraxAYvP1YLzg4GHfffTd+/vlnvPfeexAKhfy2P/74I1iWxQMPPNDk2jUaDeLj4xs8P7VajalTp0KlUuGpp56Cr68vcnJysGPHDpSVlcHFxYXf9ujRo/jjjz+wfPlyAMDatWsxa9YsvPDCC/jss8+wbNkylJaW4u2338bDDz+MAwcO8Pflzj+GDBmCtWvXIj8/Hx9++CGOHz9ucjy6f/9+TJ8+HT169MDq1atRW1uLjz/+GCNHjsT58+cRGhqKOXPmICkpCT/++CPef/99eHp6AgC8vLz4xzt27Bi2bt2KZcuWwdnZGR999BHmzp2LrKwseHh4AECrzjfqe/PNNyEQCPDcc8+hvLwcb7/9Nh544AGcPn2a3+bAgQOYPn06YmNj8corr0AgEGDDhg2YMGECjh49iqFDhwIArly5gilTpsDLywurV6+GVqvFK6+8Ah8fn0bfv9jYWLAsixMnTnT5Hveki2AJIXZhw4YNLAA2Pj6e/eSTT1hnZ2e2pqaGZVmWvffee9nx48ezLMuyISEh7MyZM/n7HT16lAXA/vDDDyb72717d4Pbuf3Vt3TpUtbR0ZFVKpX8bWPHjmUBsN999x1/m0qlYn19fdm5c+e2+FwAsAKBgL127ZrJ7Y888gjr5+fHFhUVmdw+f/581sXFhV9ffHw8C4DdsGFDg32HhISwixYtanD72LFj2bFjx/JfHzx4kAXA9ujRo8HzXrRoEQuAffXVV01uHzhwIBsbG9vi8wsJCWEBsL/99ht/W3l5Oevn58cOHDiQv+21115jnZyc2KSkJJP7/+tf/2KFQiGblZXFsizLpqenswBYhULBFhQUtPj4GRkZrFAoZN944w2T269cucKKRCKT27n38t133+VvU6lU7IABA1hvb29WrVabrIF7zUtLS1kA7Lp165pcR0FBASuRSNgpU6awOp2Ov/2TTz5hAbD/+9//WJZlWbVazXp7e7MDBgxgVSoVv92XX37JAjB5377//ntWIBCwR48eNXmsL774ggXAHj9+vMXXhxBCCOmOli9fzjZ1esf9nW/u7/qdd97JAmDLy8ubfRwA7CuvvMJ/fdddd7ESiYRNTU3lb8vNzWWdnZ3ZMWPG8Lf179/f5Bj2dq059mhKW47tbl+/i4sLu3z58mb3P3PmTDYkJKTB7R988AELgN20aRN/m1qtZuPi4li5XM5WVFSwLNv8sd6ePXtYAOyuXbtMbu/Xr5/JMVJjUlJSWADsxx9/bHL7hQsXWADsli1bmr0/AFYqlbLp6en8bevXr2cBsL6+vvz6WZZlV61axQLgt+WO7/r06cPW1tby2+3YsYMFwL788sv8bdxxZ3FxMX/bpUuXWIFAwC5cuJC/bd26dSaPcftaJRIJm5KSYrKP259/a883uHOFqKgok+PTDz/8kAXAXrlyhWVZltXr9WyvXr3YqVOnsnq9nt+upqaGDQsLYydPnszfdtddd7EymYzNzMzkb7t+/TorFAob/dnMzc1lAbBvvfVWg+8RYo+ohJkQOzRv3jzU1tZix44dqKysxI4dO5osX96yZQtcXFwwefJkFBUV8f/FxsZCLpfj4MGD/LYODg78vysrK1FUVITRo0ejpqYGCQkJJvuVy+UmPXIkEgmGDh2KtLS0Vj2HsWPHIjo6mv+aZVn89ttvmD17NliWNVnr1KlTUV5ezpeKmNOiRYtMnnd9TzzxhMnXo0ePbvXz8/f3x913381/rVAosHDhQly4cAF5eXkADO/N6NGj4ebmZvJ8J02aBJ1OhyNHjpjsc+7cuSZXWZuydetW6PV6zJs3z2S/vr6+6NWrl8l7DgAikQhLly7lv5ZIJFi6dCkKCgpw7ty5Rh/DwcEBEokEhw4dalAKz9m/fz/UajWeeeYZk76Sjz32GBQKBf766y8AwNmzZ1FQUIAnnnjCpM/P4sWLTa6Ac69ZVFQUIiMjTZ7bhAkTAKDBcyOEEEKIeXBZdZWVla2+j06nw969e3HXXXehR48e/O1+fn64//77cezYMVRUVAAw9Hy7du0akpOTG91Xa449WtKeYztXV1ecPn0aubm5bX68nTt3wtfXFwsWLOBvE4vFePrpp1FVVYXDhw+bbN/Ysd6kSZPg7++PH374gb/t6tWruHz5cqP9LOsrLi4GALi5uZnczh1f7dmzBzU1Nc3uY+LEiSbZnVzG6Ny5c+Hs7Nzgdu715I7vli1bZtJXcubMmYiMjOSPA2/duoWLFy9i8eLFJtU1/fr1w+TJk7Fz585m11ffpEmTEB4ebrIPhULBr6k95xtLliwxOT7lqp+4fV68eBHJycm4//77UVxczO+vuroaEydOxJEjR6DX66HT6bBnzx7cddddCA4O5vcXFRWFqVOnNvp8uPetM/a4J90TlTATYoe8vLwwadIkbN68GTU1NdDpdLjnnnsa3TY5ORnl5eXw9vZu9PsFBQX8v69du4aXXnoJBw4c4A/mOPX7oQBAYGAgGIYxuc3NzQ2XL19u1XMICwsz+bqwsBBlZWX48ssv8eWXX7a4VnO5fR0cmUzW4ADOzc2t1QesPXv2bPD6REREADD0ufH19UVycjIuX77cZFDw9ufb1Fpvl5ycDJZl0atXr0a/f/skZX9/fzg5OTW51uHDhzfYh1QqxVtvvYV//vOf8PHxwfDhwzFr1iwsXLgQvr6+AAxN1wGgd+/eJveVSCTo0aMH/33u/7evVywWm5xscM/txo0brX7NCCGEEGIeVVVVAGASNGpJYWEhampqGhwLAIbAiV6vR3Z2NmJiYvDqq6/izjvvREREBPr06YNp06bhoYceQr9+/QC07tijOe09tnv77bexaNEiBAUFITY2FjNmzMDChQsbHKM0JjMzE7169WowoC8qKor/fn2NHesJBAI88MAD+Pzzz1FTUwNHR0f88MMPkMlkuPfee1tcA2AInN3+OCtXrsR7772HH374AaNHj8Ydd9yBBx98sMHF2/rBLqAu+Fi/xUz927nXs6njQACIjIzEsWPHWtwuKioKe/bsQXV1dYNj1cbcvlbA9D1uz/nG7fvkgnrcPrmA96JFi5pcV3l5OVQqFWpraxs9Pu/du3ejgVLufbv9nIIQe0UBRELs1P3334/HHnsMeXl5mD59uklPu/r0ej28vb1NrlrWxx1IlZWVYezYsVAoFHj11VcRHh4OmUyG8+fP48UXXzQZ6gHApAdLfbcfoDTl9qw/bv8PPvhgk3+AuQPI5jT1B1an0zW65qayD5t6fuak1+sxefJkvPDCC41+nwvicZpaa2P7ZRgGu3btavR53N5Eu72eeeYZzJ49G9u3b8eePXvwn//8B2vXrsWBAwcwcOBAszzG7fR6Pfr27Yv33nuv0e/ffjBLCCGEEPO4evUqvL29oVAoLLL/MWPGIDU1Fb///jv27t2Lr7/+Gu+//z6++OILPProowA6duzR3mO7efPmYfTo0di2bRv27t2LdevW4a233sLWrVtb1fe7LZo61lu4cCHWrVuH7du3Y8GCBdi8eTNmzZrVINh3O67vX2NB0nfffReLFy/mX++nn34aa9euxalTpxAYGMhv19Tr1tFzAUtoaU3tOd9o7T7XrVuHAQMGNLqtXC5v17A/7n3j+j0SYu8ogEiInbr77ruxdOlSnDp1Cj///HOT24WHh2P//v0YOXJkswGoQ4cOobi4GFu3bsWYMWP429PT08267qZ4eXnB2dkZOp0OkyZNanbb5q7Cubm5NTrhNzMzs1VXis0lJSUFLMuarDUpKQkA+DKQ8PBwVFVVtfh82yo8PBwsyyIsLKxBELIxubm5Da7s3r7W5h7rn//8J/75z38iOTkZAwYMwLvvvotNmzYhJCQEAJCYmGjy2qvVaqSnp/PPm9suOTmZL0UGDI2/09PT0b9/f5PHu3TpEiZOnEhXYwkhhBArOXnyJFJTU1ssmb2dl5cXHB0dkZiY2OB7CQkJEAgEJhf/3N3dsWTJEixZsgRVVVUYM2YMVq9ezQcQgeaPPSzFz88Py5Ytw7Jly1BQUIBBgwbhjTfe4AOITR2ThISE4PLly9Dr9SZZiFxrIO4YqCV9+vTBwIED8cMPPyAwMBBZWVn4+OOPW7xfcHAwHBwcmjye79u3L/r27YuXXnoJJ06cwMiRI/HFF1/g9ddfb9W6mlP/OLD+8R13G/f9+tvdLiEhAZ6envwxakeP/dpyvtFaXMm0QqFodp9eXl5wcHBotES/secO1J2HcRmrhNg76oFIiJ2Sy+X4/PPPsXr1asyePbvJ7ebNmwedTofXXnutwfe0Wi0fbOOurtW/aqhWq/HZZ5+Zd+FNEAqFmDt3Ln777TdcvXq1wfcLCwv5f3MHEY0FCsPDw3Hq1Cmo1Wr+th07diA7O9v8i25Gbm4utm3bxn9dUVGB7777DgMGDODLbObNm4eTJ09iz549De5fVlYGrVbbrseeM2cOhEIh1qxZ0+AqMMuyfD8cjlarxfr16/mv1Wo11q9fDy8vL8TGxjb6GDU1NVAqlSa3hYeHw9nZmb/COmnSJEgkEnz00Ucm6/jmm29QXl6OmTNnAgAGDx4MLy8vfPHFFybv28aNGxu8x/PmzUNOTg6++uqrBmuqra1FdXV1Uy8LIYQQQtohMzMTixcvhkQiwfPPP9+m+wqFQkyZMgW///47MjIy+Nvz8/OxefNmjBo1is9ovP34RC6Xo2fPnvxxRWuOPcxNp9M1aOPj7e0Nf39/k8d0cnJqsB0AzJgxA3l5eSYX+7VaLT7++GPI5XKMHTu21Wt56KGHsHfvXnzwwQfw8PBoVfajWCzG4MGDcfbsWZPbKyoqGhxn9u3bFwKBwGyv5eDBg+Ht7Y0vvvjCZJ+7du3CjRs3+ONAPz8/DBgwAN9++63Jcd/Vq1exd+9ezJgxg7+tuXOA1mjL+UZrxcbGIjw8HO+88w5f5t/YPoVCIaZOnYrt27cjKyuL//6NGzcaPRcAgHPnzoFhGMTFxbV5XYTYAmUgEmLHmuu1wRk7diyWLl2KtWvX4uLFi5gyZQrEYjGSk5OxZcsWfPjhh7jnnnswYsQIuLm5YdGiRXj66afBMAy+//57q5YhvPnmmzh48CCGDRuGxx57DNHR0SgpKcH58+exf/9+lJSUADAcLLq6uuKLL76As7MznJycMGzYMISFheHRRx/Fr7/+imnTpmHevHlITU3Fpk2bTBoqW0NERAQeeeQRxMfHw8fHB//73/+Qn5+PDRs28Ns8//zz+OOPPzBr1iwsXrwYsbGxqK6uxpUrV/Drr78iIyOjXSUL4eHheP3117Fq1SpkZGTgrrvugrOzM9LT07Ft2zY8/vjjeO655/jt/f398dZbbyEjIwMRERH4+eefcfHiRXz55ZcN+iVykpKSMHHiRMybNw/R0dEQiUTYtm0b8vPzMX/+fACGK62rVq3CmjVrMG3aNNxxxx1ITEzEZ599hiFDhvBZDGKxGK+//jqWLl2KCRMm4L777kN6ejo2bNjQIGv0oYcewi+//IInnngCBw8exMiRI6HT6ZCQkIBffvkFe/bsweDBg9v8mhFCCCEEOH/+PDZt2gS9Xo+ysjLEx8fjt99+448LW9NO5navv/469u3bh1GjRmHZsmUQiURYv349VCoV3n77bX676OhojBs3DrGxsXB3d8fZs2fx66+/YsWKFQBad+xhbpWVlQgMDMQ999yD/v37Qy6XY//+/YiPj8e7777LbxcbG4uff/4ZK1euxJAhQyCXyzF79mw8/vjjWL9+PRYvXoxz584hNDQUv/76K44fP44PPvigTf0k77//frzwwgvYtm0bnnzyySaP0W5355134t///jcqKir4YO2BAwewYsUK3HvvvYiIiIBWq8X333/PB9jMQSwW46233sKSJUswduxYLFiwAPn5+fjwww8RGhqKZ599lt923bp1mD59OuLi4vDII4+gtrYWH3/8MVxcXLB69Wp+O+7C9r///W/Mnz8fYrEYs2fPblV/RE5rzzdaSyAQ4Ouvv8b06dMRExODJUuWICAgADk5OTh48CAUCgX+/PNPAMCaNWuwe/dujB49GsuWLeODyTExMY32kd+3bx9GjhzJl6ITYvesPfaZENK4DRs2sADY+Pj4ZrcLCQlhZ86c2eD2L7/8ko2NjWUdHBxYZ2dntm/fvuwLL7zA5ubm8tscP36cHT58OOvg4MD6+/uzL7zwArtnzx4WAHvw4EF+u7Fjx7IxMTENHmPRokVsSEhIi88FALt8+fJGv5efn88uX76cDQoKYsViMevr68tOnDiR/fLLL022+/3339no6GhWJBKxANgNGzbw33v33XfZgIAAViqVsiNHjmTPnj3Ljh07lh07diy/zcGDB1kA7JYtWxp9Hk5OTg1uf+WVV9jW/Frk3oM9e/aw/fr1Y6VSKRsZGdnoY1VWVrKrVq1ie/bsyUokEtbT05MdMWIE+84777BqtZplWZZNT09nAbDr1q1r8bHr++2339hRo0axTk5OrJOTExsZGckuX76cTUxM5Lfh3suzZ8+ycXFxrEwmY0NCQthPPvnEZF/cGrjXuaioiF2+fDkbGRnJOjk5sS4uLuywYcPYX375pcE6PvnkEzYyMpIVi8Wsj48P++STT7KlpaUNtvvss8/YsLAwViqVsoMHD2aPHDnS4H1jWZZVq9XsW2+9xcbExLBSqZR1c3NjY2Nj2TVr1rDl5eVteo0IIYSQ7mL58uVNHsdwf+e5/0QiEevu7s4OGzaMXbVqFZuZmdnqxwHAvvLKKya3nT9/np06dSorl8tZR0dHdvz48eyJEydMtnn99dfZoUOHsq6urqyDgwMbGRnJvvHGG/zxUFuOPW7XlmO7+utXqVTs888/z/bv3591dnZmnZyc2P79+7OfffaZyX2qqqrY+++/n3V1dWUBmBwP5+fns0uWLGE9PT1ZiUTC9u3b1+S4lWVbf6w3Y8YMFkCD1645+fn5rEgkYr///nv+trS0NPbhhx9mw8PDWZlMxrq7u7Pjx49n9+/f3+C1uP2Yvam1NnVs/fPPP7MDBw5kpVIp6+7uzj7wwAPszZs3G6xz//797MiRI1kHBwdWoVCws2fPZq9fv95gu9dee40NCAhgBQIBC4BNT09vcq0sazguX7RoUYPXpKXzjaaez+3HxJwLFy6wc+bMYT08PFipVMqGhISw8+bNY//++2+T7Q4fPszGxsayEomE7dGjB/vFF180+jksKytjJRIJ+/XXXzd4ToTYK4ZlbdgFlRBCOqHQ0FD06dMHO3bssPVSWjRu3DgUFRU1WsZBCCGEEELsx913340rV64gJSWlTfd75JFHkJSUhKNHj1poZcTcPvjgA7z99ttITU1t9SBFQmyNeiASQgghhBBCCCE2dOvWLfz111946KGH2nzfV155BfHx8Th+/LgFVkbMTaPR4L333sNLL71EwUPSqVAPREIIIYQQQgghxAbS09Nx/PhxfP311xCLxVi6dGmb9xEcHNxgAA2xX2Kx2GTQCiGdBWUgEkIIIYQQQgghNnD48GE89NBDSE9Px7fffgtfX19bL4kQQhpFPRAJIYQQQgghhBBCCCFNogxEQgghhBBCCCGEEEJIkyiASAghhBBCCCGEEEIIaVKnHKKi1+uRm5sLZ2dnMAxj6+UQQgghhLQZy7KorKyEv78/BAK6ptvZ0PEoIYQQQjq7thyPdsoAYm5uLoKCgmy9DEIIIYSQDsvOzkZgYKCtl0HaiI5HCSGEENJVtOZ4tFMGEJ2dnQEYnqBCobDY42g0GuzduxdTpkyBWCy22ON0J/SaWga9ruZHr6n50WtqGfS6mp+1XtOKigoEBQXxxzWkc6Hj0e6N3hf7Re+NfaL3xT7R+2KfrPm+tOV4tFMGELkyEYVCYfEDNkdHRygUCvphMhN6TS2DXlfzo9fU/Og1tQx6Xc3P2q8plb92TnQ82r3R+2K/6L2xT/S+2Cd6X+yTLd6X1hyPUsMdQgghhBBCCCGEEEJIkyiASAghhBBCCCGEEEIIaRIFEAkhhBBCCCGEEEIIIU2iACIhhBBCCCGEEEIIIaRJFEAkhBBCCCGEEEIIIYQ0iQKIhBBCCCGEEEIIIYSQJlEAkRBCCCGEEEIIIYQQ0iQKIBJCCCGEEEIIIYQQQppEAURCCCGEEEIIIYQQQkiTKIBICCGEEEIIIYQQQghpEgUQCSGEEEIIIYQQQgghTaIAIiGEEEIIIYQQQgghpEkUQCSEEEIIIYQQQgghhDSJAoiEEEKIjaQVVkGt1dt6GYQQQgixAxlF1VBpdbZeBiGENIoCiIQQQogNHEwswIR3D+O/O2/YeimEEEIIsbFzmSUY984hLP/hPH48k4WUgipbL4kQQkxQAJEQQgixgWPJRQCA7RdzoNOzNl4NIYQQQmxp+4VcAMD+GwVYtfUKVmw+b+MVEUKIKQogEkIIITaQkFcBACir0eBCVqmNV0MIIYQQW3J3kph8nZBXaaOVEEJI4yiASLqlG7cq8M2xdOgp64cQYiOJ9U4M/k4osOFKCCGEEGJrZTXqBrfRuQohxJ5QAJF0S//ZfhWv7biOPdfybL0UQkg3VFipQlFV3YnCQQogEkIIId1aaY2mwW0ljQQVCSHEViiASLodlmVx/ZahdPByTrmNV0MI6Y648mVvZykEjKFM6WZpjY1XRQghhBBbKTUGC9+9tz885YZy5rxypS2XRAghJiiASLqd3HIlatQ6AECCMZBICCHWxJUvx4a4YXCIOwDKQiSEEEK6szJjBqKbkxg+ChkAoKCSAoiEEPtBAUTS7STl1/Udu3GLmhMTQqyP+90T6avA+EhvANQHkRBCCOnOSqoNGYiujhL4GgOIeeUqWy6JEEJMUACRdDsp+VX8v/MqlCitpt4ihBDrSsw3ZD/39nXGxChDAPFEajFq1FpbLosQQgghNsINUXFzlMDHxRhArKAMREKI/aAAIul2kgtMsw5v5FEZMyHEerQ6PZKMFzKi/JzRy1uOQDcHqLV6HE8ptvHqCCGEEGJtaq0e1cYWS26OYj4DMZ96IBJC7AgFEEm3k1xgOHGXigwffypjJoRYU0ZxNdRaPRwlQgS5OYJhGEw0ljEfoDJmQgghpNvhsg8FDKCQ1QUQfz6bjQ/3J+Ovy7eQf1s24uGkQuy8cgtqrd7q6yWEdE8UQCTdCsuyfAkzVzZ4gwapEEKsKME4QCXCxxkCAQMAmBDlAwA4kJAPlmVttjZCCCGEWF+pcYCKi4MYAgGDaH8F/7339ydh+ebzWP7Def62ggolHt4Yj2U/nMe9609afb2EkO6JAoikW8mrUKJSpYVQwGB6Hz8AQAKVMBNCrCjBmPUc5efM3zYszB2OEiHyK1S4lku/kwghhJDupJTrf+gkAQD0CXDBrn+Mxht394GroxgAkF1ag5OpxUgrrEJKYRV0esMFx0vZZahUamyzcEJIt0IBRNKtJBuzD0M9HNEv0AUAkJRfBa2OUv8JIdbBZSBG+tZlF8jEQozs6QmAypgJIYSQ7qb+ABVOlJ8CDwwLwbZlIwEA+RUqLPjqFCa8exhZxTUm979FvRIJIVZAAUTSrXD9DyN8nBHk5ggniRBqrR5pRdU2XhkhpLvgsp57+zqb3M71QfybAoiEEEJIt8JdPPR2ljb4npNU2OC2HZdvmXydW1ZrmYURQkg9FEAk3UqKcQJzL285BAIGkX6GDCDqg0gIsYZKpQY3Sw0H+ZG3BRDHGwOIl7LLUFipsvraCCGEEGJ9ZzNK8MvZm2AYYMnIsAbfd5KIGtx2LKXI5Os8ykAkhFgBBRBJt5JkLGHu6WM4cedO4GkSMyHEGpLyDb9rfBUyuNYrUwIAH4UMfQMMrRUOJlIWIiGEENIdxGeUAgCmRvtiaJh7g+87iBtmIHLcjP0RcymASAixAgogkm6DZVkk59dlIAKG3iIAZSASQqyDu1gR6efc6PcnGLMQD1IZMyGEENItcFUHIZ6OjX5fIGDgKGk8iMgFHG9RCTMhxAoogEi6jcJKFSqUWggYoIeXEwAKIBJCrIvrf1h/gEp9E6MMAcQjSYVQa2m4EyGEENLVFVYZAohe8ob9DzlO0oZlzAAwNMwDAA1RIYRYBwUQSbfBDVAJ9XCCVGS4iseVMBdUqlBcRT3HCOkMWJa19RLaLZGfwNx4BmIffxd4yqWoVutwJr3EmksjhBBCiA0UVBiCf16NDFDhONXLQOwfaGh34u0sRZTxeCK3nDIQCSGWRwFE0m1w5cs9jeXLgOFqXoiHoVwgIY/6IBJi7zadykTf1XtxOq3Y1ktpM5Zl+d8zTZUwCwQMJkR6AQD+Tsi32toIIYQQYht8BmIzAUTHeoNUhod7YPvykfjx8eHwc3UAYBii0pkvsBJCOgcKIJJuI8mYgdjLR25ye5QvlTET0ln8dfkWqlRafHYo1dZLabPcciUqlVqIBAx6eMqb3G5CpA8A4O8bBXQyQAghhHRxXA9Eb2dZk9vI65UwyyUiDAhyRbiXHJ5yw0C2GrUOKmp9QgixMAogkm4jxTiBuZe3aeZPXR9EykAkxN6lF1UDAI4kFyKnkzUMTzBepOjpLYdE1PSf31G9PCERCpBVUoPUwmprLY8QQgghVqbU6FCp1AJoIQNRWlfCLJfVBRPrZybWqHUWWCEhhNShACLpFliWRVKBcQLzbRmIXCkhZSASYt+qVVrkGfsEsSyw5Wy2jVfUNgkt9D/kyKUiDOthmKpI05gJIYSQrovLPpSIBFDIGh+UAgBO9QKF9QeqCAUMZGLDKX21SmuhVRJCiAEFEEm3UFytRlmNBgwDhHuZBhCjjRmIKQVV0Ogo9Z8Qe8VlH3K2nL0Jnb7zlPhyAcTeTUxgrm9ipGEaM/VBJIQQQrquAr58WQqGYZrczqleBqLzbROZuSxEykAkhFgaBRBJt5BkHKAS7O4ImVho8r1ANwfIpSKodXqkUbkgIXYrzRhA7BvgAhcHMXLKanEspcjGq2o9roS5qQEq9XF9EOMzSlFeq7HougghhBBiG1wGYnPly4BpqbJTgwCi4dymRk0ZiIQQy6IAIukWUrgBKt4NBxcwDMOXFFIZMyH2K63Q8HMc6euMuwcGAAB+js+y5ZJaTaXV8QHQqFZkIAZ7OKKntxw6PYsjSYWWXh4hhBBCbKCw0tCaxUvefADRqYkeiEBdeTNlIBJCLI0CiKRbSOYGqPg0nvlTN0iFAoiE2CuuhLmHlxz3DQkCAOy7no+iKpUtl9UqKQVV0OlZuDiI4aNo/iSBw5UxH6A+iIQQQkiXlFlcAwAIcndsdrv6GYi3lzA7GDMQqQciIcTSKIBIuoVkboBKIxmIQF0A8ToFEAmxW1yLgR5eTojyU6B/kCs0OhbbzufYeGUtS7hVN0CluR5H9U0wBhAPJRZ0ql6PhBBCCGkd7uJomKdTs9vJpU2XMHPZibUaykAkhFhWmwKIn3/+Ofr16weFQgGFQoG4uDjs2rWL/75SqcTy5cvh4eEBuVyOuXPnIj/ftAF8VlYWZs6cCUdHR3h7e+P555+HVktXS4hl1ZUwN56ByPUk44YcEELsC8uydRmIxoPs+cYsxJ/is8Cy9h1gS8xv3QTm+mJD3KCQiVBao8HF7FJLLY0QQgjpFvR6Fp8fSsWZ9BJbL4WXdtuxTVNEwrqLj7eXMHPZidWqugBiUn4lvj6ahh2Xc821VEIIaVsAMTAwEG+++SbOnTuHs2fPYsKECbjzzjtx7do1AMCzzz6LP//8E1u2bMHhw4eRm5uLOXPm8PfX6XSYOXMm1Go1Tpw4gW+//RYbN27Eyy+/bN5nRUg9JdVqFFWpAQDh3o3/cTZkBRkaGXeGckhCupvCShWqVFoIGEN/QACY3d8fjhIhUgurcS7TvgNsN/gBKi33P+SIhAKM7W2cxnyDypgJIYR0P/uv5+PBr08jp6y2zfetVevw1+VbyK8w9Bk8mVaMt3YnYM2f18y9zHbR6PTIKjGUMId5NR9ArH+d1EnS+BCVE6lFeOy7sxj99gFMef8IXv/rBlZsvoCbpTXmXTghpNtqUwBx9uzZmDFjBnr16oWIiAi88cYbkMvlOHXqFMrLy/HNN9/gvffew4QJExAbG4sNGzbgxIkTOHXqFABg7969uH79OjZt2oQBAwZg+vTpeO211/Dpp59CrVZb5AkSkmzM/Al0czDpH1Kfo0SEUA/DH27qg0iI/eGu0Ae6OUIqMhwoy6UizOrnBwD4KT7bZmtrDS67uS0ZiAD1QSSEENK9PfrdWRxLKcK7exNbfR+9nsWRWwwmvn8Uyzefx3+2XwVQ97e4pNo+zjuzS2qg07NwEAvh4yxrdtv6dRZCgWkrFO78ZsflW9h3PR/ZJbWo3y0lu6T54KtKS6XPhJDWaXcPRJ1Oh59++gnV1dWIi4vDuXPnoNFoMGnSJH6byMhIBAcH4+TJkwCAkydPom/fvvDx8eG3mTp1KioqKvgsRkLMLdlYvhzRxAAVDndiz/UqI4TYj/r9D+u7b0gwAOCvy7dQodRYfV2tUVylQmGlIbO5pd9Dtxsb4QUBYzjpoQwCQggh3Un9/r9tCfrtuZ6P3zKEKDRWIHFZflxLoyo7GDai1Ojw7r4kAECopxMEgub7Iwub6Z/sJBGafP3dw0Nx9IXxGBbmDgAoME56bsy6PQnou3ovPjuUgvSiaiTmVUJPfZcJIU1oPB2rGVeuXEFcXByUSiXkcjm2bduG6OhoXLx4ERKJBK6uribb+/j4IC8vDwCQl5dnEjzkvs99rykqlQoqVV1ZaUWFIUNMo9FAo7HcCSO3b0s+Rndji9c0Mc/weenh6djs40Z4O2EXgGs5ZZ3uPafPqvnRa2p+HXlNUwsMP8ch7g4m9+/r54SeXk5IKazG9vPZWGDsi2hPruUYyquD3R0gEbBtev5yCYNBwa44m1mG/ddu4YFhwQ22oc+q+VnrNaX3jBBCmpZWWMX/2/G2IFlzCowX7QJdZbhZpuRbGaUaA4jVKi1Ylm31UDNL2HLuJv66fAtAw4ujjbljgD++PJKK0b28Gnyv/mvj5SzFmAjDNt4KQ1YjdxGzMbuu5EGt1ePt3Yl4e7chy7OHpxPmDw1CL29n+LnK0Nun9QPgCCFdW5sDiL1798bFixdRXl6OX3/9FYsWLcLhw4ctsTbe2rVrsWbNmga37927F46OzY+8N4d9+/ZZ/DG6G2u+pqeuCwAIUHMrFTt3pjS5XXUJA0CIM8m52LnTvsshm0KfVfOj19T82vOankow/hznpWPnzjST7/VxZJACIb76+zpcCq+YaZXmc+iW4XeLK6qxc+fONt/fjzXc/+dj1+FWfLXJ7eizan6Wfk1raiirlBBCmnIlp5z/d0FF63uU16gNJbk9veW4WaZESbUKOj2L5AJDlZGeNUwsrt/a6FxmKd7dm4hgd0e8ObefmZ5B0/LL67ICl40Lb3F7uVSEg8+NazSQ51hvKrOHk4T/t5dcCqD5AGL94SwOYiE0Oj3Siqrx350J/O1jIrzw8YKBcHEQt7hOQkjX1uYAokQiQc+ePQEAsbGxiI+Px4cffoj77rsParUaZWVlJlmI+fn58PX1BQD4+vrizJkzJvvjpjRz2zRm1apVWLlyJf91RUUFgoKCMGXKFCgUrW9I31YajQb79u3D5MmTIRbTL0xzsMVr+vqVQwDUmDNpBPoHujS5Xf+yWnydeBSFKgEmTZkMiajdFf5WR59V86PX1Pw68pp+kHQMQA1mjR2KEeEeJt8bXq3GX+sOI7saCB04CtFtGFRiDUe3XQMycjCmX0/MmNizzffvlV+FPz85gdQqEcZNGteglyt9Vs3PWq8pV1FBCCHEFMuyOJVWzH99q7zpMtzbcQHEQDcHMIwhYJhWWIXSmrqs7yqVlv97mleuxPwvT0KjY3EitRj/mh4JV0dJo/s2l1qNYY1PjA1HjH/T5yf1NZUF6HRbBiLHW2H4d0EzAcRKpaGc+48VI9Ev0BVVKi22X8jB3zfyUVCpQnJBFY4kFeLbExl4emKvVq2TENJ1tTmAeDu9Xg+VSoXY2FiIxWL8/fffmDt3LgAgMTERWVlZiIuLAwDExcXhjTfeQEFBAby9DY3h9+3bB4VCgejo6CYfQyqVQiqVNrhdLBZb5WTJWo/TnVjrNS2rUfP9TyL9XSEWN/2RD/EUwVkmQqVSi6wyFaLsLAjRGvRZNT96Tc2vra+pRqdHdqmhAXiEn0uD+/q4ijElxhd/Xb6F3y7cQv9gj8Z2YzNJxpKpmADXdn2WogJcEeDqgJyyWsRnVmBStE+j29Fn1fws/ZrS+0UIIQ39eCYL/915gw9uAUB+hRI6PdtggEhjuACis0wEN0cJSqrVOJVeYrJNlVILb2Nb4l1Xb0Gjq+v7l5BXieE9LHsswQUQHcStL81uioOk8QxEb+eWMxC519hZZvh7JJeK8ODwEDw4PAQA8OH+ZLy/P4n6MBNCALRxiMqqVatw5MgRZGRk4MqVK1i1ahUOHTqEBx54AC4uLnjkkUewcuVKHDx4EOfOncOSJUsQFxeH4cOHAwCmTJmC6OhoPPTQQ7h06RL27NmDl156CcuXL280QEhIR3HNkgNcHSCXNh8vZxgGUb6GoCFNYibEfmSX1EDbwpTC+cbeh9su5ECpsZ9pgjo9iyTjJPjebZzAzGEYBhOjDBfd/rbjacxHkwuRkEe/O4l9WL16NRiGMfkvMjKS/75SqcTy5cvh4eEBuVyOuXPn8lUxhBDb+ik+mw9sPTOpFxgG0OpZFFe1royZCyA6SUR8QK1+NiMAVKvqjhV2XTXtxZ+YZ/mBikrjGh0kHa94qp+B6CGvO6fmshGbGqKi07P8QBmFrPHzJHe54fUrq6GevYSQNgYQCwoKsHDhQvTu3RsTJ05EfHw89uzZg8mTJwMA3n//fcyaNQtz587FmDFj4Ovri61bt/L3FwqF2LFjB4RCIeLi4vDggw9i4cKFePXVV837rAgx4iYw9/SWt2r7KD/jJGYrHDgQQlqHm8Ac1syUwpHhnghwdUClUotdV29Zc3nNyiyuhlKjh0wsQIhHy03SmzIh0hBAPJCQD5a1v+mIaYVVWPi/M7jjk+M4lGi/QU7SvcTExODWrVv8f8eOHeO/9+yzz+LPP//Eli1bcPjwYeTm5mLOnDk2XC0hhFNWY6ge+v6RoXhmUgR/8bC1Zcw1akNQzEEihKcxoHb6tgBipcoQECupViM+w5CdePfAAACwysUwc2YgmvRAlNfPQDS8bk2VMFfVy/DkMhBv5+ZouJ0CiIQQoI0lzN98802z35fJZPj000/x6aefNrlNSEhIu5rIE9IeXOZPr1YGECP9KAOREHuTXmQMIDYzpVAgYHDfkCC8ty8JP53Jxt0DA621vGZxFyN6+zi3quyqKcN7eMBBLER+hQrXcivQJ6B1/ZKs5XR6CVgWUGv1ePy7c/jioUGYENl4qTUh1iISiRrtsV1eXo5vvvkGmzdvxoQJEwAAGzZsQFRUFE6dOsVXzhBCbKOk2hBA9HNxMPzfVYa8CiVuldeif5Bri/evNmb3OUqEfECNm8TMb2PMQLyWWw6WNVyknBDpjW0XcvDL2ZsI95KjrEYDAQOwAPoGuGB8pDfEQvP0SOeqJWRmCCDWz0D0bCQDsaxGA5VWB6nI9LEqlIagoFQkaLL3u5uxF2RpjbrR7xNCupcO90AkxJ5xJcy9fFqbgUgBRELsTVqR4ec43LP5DL57YgPxwf4knE4vQVphFXp4te7n3pL4AGI7y5c5MrEQo3p5Yt/1fBxIKLC7AOKFrFIA4PvILv3+HD5/ILbJfo2EWENycjL8/f0hk8kQFxeHtWvXIjg4GOfOnYNGo8GkSZP4bSMjIxEcHIyTJ082GUBUqVRQqeoyebghOBqNBhqN5bJzuH1b8jFI29H7Yhkanb6uL5+EgUajQaCrDBeygJ/OZGFChEeTw0Q41VxgTAi4O5pm1jlJhKhW61Beo4JGo8GNXMOk517eTujpaQhY6vQsXv/rRoP9ejhJ8MCwIKwY16PFNbSEy5KUCDr+GRIL6ioTXGVCfn9yMSAWMtDoWOSVVsPf1cHkfqVVhoxOZ5moyTXIJYbnWVqj7vA66WfGPtH7Yp+s+b605TEogEi6tOR8LoDYupP33j7OYBjDVcrCSpXJJDNCiG3wJczNZCACgL+rA8ZGeOFgYiF+OXsT/5oe2ez21pBgvBgR6dvxoUwTI72x73o+/k4osLtJiOezygAA6+7phz8u5WLnlTw8+cM5fHr/IEyJaZgBRoilDRs2DBs3bkTv3r1x69YtrFmzBqNHj8bVq1eRl5cHiUQCV1dXk/v4+PggLy+v8R0CWLt2LdasWdPg9r1798LR0dHcT6GBffv2WfwxSNvR+2JeFWoAEIEBixOH9kPAAFEAdjFCHEoqwn+/342Bns238sgrFgJgkHj1MoqrAaAu885PpkWKmsHpcxchzrmAv1MEAAQQVOQhIT4XfdwEyK5i4OPIwlMKforztVIGxdVqfHQgFZLCRAR18BplXqFhjVcvXwCyO9aapLAW4E7rEy7Foza17nuuYiEKdQx+2nkIka6mj5NSbrifQKtqskKwRGXYprRahb/+2okOxk0B0M+MvaL3xT5Z432pqWn9kCQKIJIuq0KpQV6F4cpaa3sgOkiECPNwQlpRNW7cqoCXs5cll0gIaYU0YwlzD8+Wf47nDw3GwcRC/HruJv45JcJspUbtlWhsoxDZwQxEABhv7IN4+WaZXV3gKK/V8Nneg0PdMTHKBwxzEX9dvoVlP5zHJ/cPwrQ+FEQk1jV9+nT+3/369cOwYcMQEhKCX375BQ4ODs3cs2mrVq3CypUr+a8rKioQFBSEKVOmQKHo+EWCpmg0Guzbtw+TJ0+myd12hN4Xy0guqALOnYDCQYxZM6fyt+c5JuC7U1nQeYRhxozmLxB+kHQMqK7ByGGDkV2mwl/Z1wEYMgj7hnsi5UIuQntFYsboMHz9xSkAFZg5aiCmxfhg1szG96nR6bFo4znEZ5TCJawfZgzpWKuUT1NPAFVVGDV8KEaEd2zic0GlCq9fPAwAmD15PALd6n7H7au6jB1X8iDz740Z43qY3O/vGwXA9Yvw9XTBjBmNZ17XqLVYc/4AdCyDsZOmtDiUsjn0M2Of6H2xT9Z8X7iKitagACLpsrjsQ1+FDIomGgM3JspPwQcQx0RQAJEQW6pUalBobP7dUgYiYBg24imXoqhKhQMJBZhqw+y3apUWmcWGK3odLWEGAB+FDH0CFLiaU4FDiQW4d3BQh/dpDpeyywAAIR6OfO+lD+8bACHD4I9LuVix+Tw+XjAQ0/v62XCVpLtzdXVFREQEUlJSMHnyZKjVapSVlZlkIebn5zfaM5EjlUohlTYM3IvFYqucdFnrcUjb0PtiXlVqQ5acu5PU5HXtG+gKIAuphdUtvt41xv6CCkcp+sjrsoOH9/DgzwlqNSxKa3W4kmM4cY4JcG12v2Kx4SJZfEYprudVQSwWo6xGjZyyWsT4t72tiFKrBwDIHaQd/vy4yevSAn1cHSEW153iDwh2w44rebh6q7LB49RoDa+1i4OkyTUoRCJIRAKotXpUqVm4yTv+WaefGftE74t9ssb70pb92zY1gxALSikwDlBpZf9DDjeJmfogEmJ73AAVT7m0VRcCxEIB7ok1ZAX8HJ9t0bW1hMs+9HaWwkNunmxBbjDJgQT7mXR83tj/cGC9xvYioQDvzeuPuwb4Q6tnseLHC9hxOddGKyQEqKqqQmpqKvz8/BAbGwuxWIy///6b/35iYiKysrIQFxdnw1USQrgBKq639S6MMLYjSjImCDSnpt4Qlf5Brtj37Bj89mQc3r9vAOQyQ3AtragKQ/9r+B0gEwsQ4tHyRco+xkDhtdxyqLV63PvFScz6+BgOJhRg99U8HEsuQqahZrpFZp3CLBHh+0eG4odHh8FRYpofxA2d4S721cf3mpQ1nVPEMAxNYiaE8CgDkXRZfP9D77Zl/nC9yrjhB4QQ2+ECiD1akX3IuW9IEL44nIpDiQW4VV7LT3G0tkQzDVCpb2KkNz76OxlHkgqh1uqbnJpoTReM/Q8HBruZ3C4SCvDuvAEQMAy2XsjBP366CD0L3NHf3warJN3Nc889h9mzZyMkJAS5ubl45ZVXIBQKsWDBAri4uOCRRx7BypUr4e7uDoVCgaeeegpxcXE0gZkQGyszTvvlpv9yuHZERVUqlFSr4e4kaXBfAGBZ1iSACJj2QncyluDuvFLX73TV9CgIBS039+trHGB2+WY5Il7axd++ZGO8yXa/PRmH2BD3ZvelNK7RQdLxACIAjO7VeNVUjL8CAsZQ5vzpwRQsjAuBs/GCbEWtISDoLG3+Aq2rgwT5FSqaxEwIoQxE0nUlt3ECMyfK3xBATCmogkqrM/u6CCGtl1rI9T9sfQAxzNMJw8LcoWeBX8/etNTSWsQNUOGmu5tD3wAXeMqlqFbrcCa9xGz7bS+9nuUnMA+6LYAIAEIBg3X39sc9sYHQ6Vk889MF/H4xx9rLJN3QzZs3sWDBAvTu3Rvz5s2Dh4cHTp06BS8vw0n2+++/j1mzZmHu3LkYM2YMfH19sXXrVhuvmhBSasxyuz2A6CQV8b39HvvuLMa8fRCn0oob3F+l1UOnN5Tm3p6NBwDOt/Xwe3pCTywaEdqqtQW5OzTIjOSIhQz/Pe7CWnPMmYHYHEeJiG8hsm5PIga/vh/3f3UK5TUaVKoMGYgKh+ZzirjnVVZLGYiEdHcUQCRdFtfUv1crB6hw/F1kUMhE0OpZfh+EENtIKzT8DLYlAxEA5g819Af8+Ww29PqOTTdsrxt55hugwhEIGEyINARA/k7IN9t+2yutqBoVSi1kYgEi/Rp/nkIBg7fn9sO8wYHQs8CzP1/Etgu2C+yS7uGnn35Cbm4uVCoVbt68iZ9++gnh4eH892UyGT799FOUlJSguroaW7dubbb/ISHEOkr5DMSGgbrexkzCc5mlyCqpwZ+XGrbGqFXXXfx3bCS7z+m2AGJcuGer18Ywhr9ni0eEYvXsaLw5py//vXG9vXHfEMOxx83S2mb3o9HpoTUem1g6gAgAH9w3AO/e2x/hXk5QafU4kVqMTaczUak0ZiC20CKGC+aWUQYiId0eBRBJl1Sl0iKnzPDHu7UTmDkMw/AZQwm3qIyZEFviSpjDWjGBub7pffzgLBPhZmktTqQ2zFCwNJZlLVLCDBgGxQCGPogsa5vgKIfrf9gvwLXZidcCAYM35/TDgqFB0LPAyl8u4ddzFEQkhBBiqtTYA9GtkRLl+4YEIcC1ri1JWmHDfoPVakNWnZhhGy1Lrj9FWCoSYGCwa5vWNyXGF6vviMHikWGYPzQYS8f2QKCbA16aGYVA49q4c5CmcNmHACCTWP50XCwUYG5sIPavHIvnp/YGAHx/MhMZRYZBb831QAQANydDgLG0mjIQCenuKIBIuiQuc9DLWQpXx8Z7pDSHCyDSIBVCbIdl2Xb1QAQAmViIuwcGAAB+is8y+9paklehRHmtBkIB0+aLGC0Z1csLYiGDzOIapBW1rlm7pdT1P3RtcVuBgMEbd/XFA8OCwbLA879ewi82HnRDCCHEvjRVwgwYgnfH/zUB25ePBACkFtZVClUqNYjPKOGDXE21FqwfQJw/JAiyDmYArpoehWMvTkCIhxMCjCXWLWUgcv0PBQwgaebim7kxDINHR4fBUy5BXoUSJ40l4C1lIHLnUtQDkRBCAUTSJSUbp59GtLH/IYefxJxHAURCbCW/QoUatQ5CAYMgN8c2358rJdp7LZ+f6mgt3BCmHp5OkIrMW54kl4owvIcHAODADdtOY+b6H94+QKUpAgGD1+/qg4eGh4BlgRd+u4yfzlg/wEsIIcQ+NVfCzOEuKhZUqlCh1OB4ShEGv74f935xEmv+vAYAkDbxpzcmwAVB7g6Y1c8PL82KNuvaA43HKjmlNc1uV7//IcO0PLzFnKQiId65tz9GhHvAUSKERCTAoBYuAro6GN6LcuqBSEi3R1OYSZdU1/+wfaWDdRmIlWBZ1up/3Akhdf0Pg90d2zVtOMbfBX0DXHAlpxzbLuTgkVFh5l5ik7j2B5FmHKBS34RIbxxNLsLfCflYHBdkkcdoSZVKiyTjxZq2lIAxDINX74yBgAG+PZmJf229Ah3L4oFhIRZaKSGEkM6CDyA2MWUZABQyMbydpSioVCGtsBrbLuRApdUDAM5mGi5sNVUZ7OIgxpHnx1vk2J4rr65QalGh1EDRRGYfH0A00wTmthrX2xvjentDq9NDx7ItXuh0owxEQogRZSCSLok7qW1v6WCEjzMEDFBSrUZhpcqcSyOEtFIa3/+wbeXL9XFZiD/HZ1m1X2CCMXvZnANU6uP6IMZnlKLCRhkBl7PLoGcNJ0w+Clmb7sswDFbfEYMlI0MBAP/edhXfn8ww/yIJIYR0KmXNlDDXF+5lOMZPLahCfEZJg+83lYEIwGKJAU5SET+xOKeZMmZu0EtHy6c7SiQUtKpKgntOXHk5IaT7ogAi6ZKS2zmBmSMTC/mgxXXqg0iITXDN0Xt0IIB4xwB/yMQCJOVX4UJ2mZlW1rJEC0xgri/Ewwk9veXQ6VkcTbH+kBigboBKWxvQcxiGwcuzovGoMTP0P79fw7cnMsy0OkIIIZ2NXs/yk36bK2EGgF7GNkWrtl5BZnENGMb0b65UaJshY1wW4vQPj2LNn9f4Vh/11S9h7gy4bFCawkwIoQAi6XJq1Fq+eXGET/tP3vlJzHk0iZkQW0gvMlwICGvjAJX6FDIxZvb1BwD8fMY6AzvUWj3fRsFSJcxAXRbiocRCiz1Gc+oGqLSu/2FjGIbBv2dGYemYHgCAV/64hu8oE5EQQrqlCqUGemPcr6UhiI+MCkOgmwPUOkPpcoi7I2b09eO/L7XRWW79i2objmfg7s9OYPfVPJNtlDYuYW4rrgdiGWUgEtLtUQCRdDmpBYasJU+5pNn+KS2hScyE2BZXwtzDs2NTjOcPNZQx/3k5F1UqbYfX1ZK0oipo9SycZSL4u7SttLctuADi4eQi/oTLWliW5TM6W2q+3hKGYfCv6ZF4Ymw4AOC1Hdcpy4EQQrohrkRWLhW12Ps4xMMJu/4xGoNDDBexpvbxxUPDQ7BgaBD6+Csw3Ns2GYirZ8fg1yfi8OH8AfAwnoecSjOtFFBqDEFPW5cwtxYXzK1QaqCz9gEHIcSuUACRdDnJBR3rf8jhJzFTAJEQq1Nr9cguMUwx7NGBDEQAGBzihh5eTqhR6/DnpVxzLK9Z/AAVX2eLDmCKDXGDQiZCaY0GmVUWe5hGZRbXoKRaDYlQgGj/jmdZMgyDF6f1Rm8fZ2h0LP628XRpQggh1ldSzQ1Qab58meMsE2PTo8PwzaLBeHpCL7g5SbB2Tj9se3I4+rjbJtAlEgowONQddw4IwKoZUQDq+iJzuB6InaWEmeuByLI0iZmQ7o4CiKTLScrv2ARmDpeBmFpYzZcaEEKsI6ukGnoWcJII4e0s7dC+GIbBfOMwlZ/iLV/GfIMfoGK58mUAEAsFGNvbkIV4tdS6f84vZBt6OvUJULSqAXtrMAyDqX18AQC7r+W1sDUhhJCupq7/YesriGRiISZG+cBJKrLUstqN68mYmFdpMsiN64EoE3eOU3GxUABn4+tLk5gJ6d46x28tQtogxZiByDVXbi9fhQwuDmLo9Czfz4wQYh3cAJUwLyezZPHNGRQIkYDBpewyi2cVcwNUeltogEp9E41lzNdKLJfp2JjzmWUAOtb/sDHTjQHEI0mFqLZCuTkhhBD7wWUgttT/sLPo6S2HgDGUZhdWqVBarcZXR9Kwx3iRrLNkIAKAqxPXB5ECiIR0ZxRAJF1O3QTmjp28MwxDZcyE2Ii5+h9yPOVSTI72AQD8bOEsRK6Emfv9YUljI7wgYIBbtQxyy2ot/ngcLgOxvROYmxLp64wQD0eotHocTrLNcBhCCCG2wQ3pcG9hAnNnIRMLEephaMOSlFeF9UfS8MbOGziaXASg8wxRAQBXB24SM5UwE9KdUQCRdClKjQ5Zxr5pHc1ABOoPUqFJzIRYU7oxA7Gj/Q/ru89YxrztQo7F2hKU1aiRV6EE0LEp8K3l5iTBwCBXAMDBpCKLPx5gmHTP/U4cZOYMRIZhMC3GWMZ8lcqYCSGkO+HKY7tKBiJQdyyQkFfBV0kBhhYtYyO8bLWsNuP6IJZSAJGQbo0CiKRLSSmoAssCbo5ifvJZR0QZe5jd3vyYEGJZaUWGTOIwT/MFEEf38oK/iwzltRq+fMjcEozly4FuDnCWWSeDYnxvwwnIwUTrZOxduVkOnZ6Fj0IKPwtMmeb6IB5IKIBKS/1nCSGku+ACiO5mOIa3FxHGdiZJ+ZV8ksN3Dw/F1TVTMa2Pny2X1iZcX0oqYSake6MAImkVlmXx35038MrvV02aANublHrly+bom1aXgVhh18+bkK4m3VjCHO5lnhJmABAKGNw72JCFaKky5oRb1hmgUt/43p4AgJNpJahRW75v4PmsMgCG7ENLTJkeEOgKH4UUVSotjqdYJ6uSEEKI7ZVWG7Lb3LpICTNQN0glIa8ugBjs7miRv5+W5MZnIFIAkZDujAKIpFXiM0rx5ZE0fHsyk59ybI+SzTRAhdPLRw6hgEFpjQb5FSqz7JMQ0rzyWg2KqgwHqKFmzEAEgHlDgsAwwInUYmQWV5t13wCQmG/4HRRphQEqnF7ecrhLWai1epxIKbb4413Iskz/Q45AwGAqlTETQki305VLmC/fLIdSo4eAAfxdHWy8qrZzdaQeiIQQCiCSVvr6aBr/77OZJTZcSfOS87kMRPMEEGViIXoYAxg3qIyZEKvgsg99FFLIpSKz7jvA1QFjehlKfjeeyDDrvoG6fqmRVhigwmEYBjGuhgzpvxMKLPpYLMviQnYZAPNPYK6P64O473o+tDq9xR6HEEKI/eiKJcyhHo6QiOpOuf1dHUy+7iy4HogUQCSke+t8v72I1aUXVWPfjXz+63MZpTZcTfP4EmYzDi+IrFfGTAixvLRC8/c/rO/R0WEAgB9OZeFmaY3Z9qvXs0jiMxCtV8IMADFuhgDiwYQCi7ZbuFlai8JKFUQCBn0DXCz2OEPD3OHmKEZpjQZnMuz3ohUhhJCmqbV67Luej4/+TsaOy7ktbs8N6HDtQiXMIqEAPeu1Ywl2d7ThatqP64FIJcyEdG8UQCQt2nA8HSwLeMoNfzjOZtpnAFGp0SHDWJJorgxEAIgyZhLRJGZCrIPLQOxhxv6H9Y3q6YkR4R5Q6/R4f1+y2fabXVqDGrUOEpEAoR7WPUHo6cLCQSxAXoUS1y14sYPLPoz2V0AmFlrscURCASZH+wAA9lAZMyGEdDrVKi1mfXwUj313Fu/tS8KKzRew88qtJrdnWZYf0OHWhUqYAdOqhBArHx+YC01hJoQAFEAkLSirUWPL2ZsAgNfv6gOGAbJKalBQqbTxyhpKL6qGngUUMhG8nKVm2y83SCWBMhAJsYq0QmMA0UIZiAzD4MVpkQCArRduIjHPPBcHuIsMET5yiITW/fMqFgAjwj0AAAduWK6M+bzxAtIgC5Yvc6YZpzHvuZYPvZ6GWBFCSGfy1dE0JOVXQSxk4KuQAQBe/PUyKpWNB6CqVFpodIbf9V0tgLh0TDj6BBjOJ4b38LDxatqHe0/KKQORkG6NAoikWT+czkKtRocoPwWmxviit7E0+LwdZiEmG8uXI3zMM4GZE2UsRUwrqoZSozPbfgkhjUs1ljD38LJMABEA+ge5YkZfX7AssG5Pgln2mZBn/QnM9Y3vbejtaMk+iHX9D10t9hicEeGekEtFyKtQ4tLNMos/HiGEkI4pr9Xg9R3X8dA3p/HpwRQAwAf3DcSxF8cj1MMRlSotDiUWNnpfrreeTCyAg8RyGe620NvXGX+uGIWLL0/GnQMCbL2cdqEMREIIQAFE0gy1Vo9vjUMGHh0VBoZhEBtiyDo5a4d9EFPyzTuBmeOjkMLNUQydnuWHtJCGCiqVWPDlKWy/kGPrpZBOTK9n+VYEYZ6WKWHm/HNKbwgFDPbfKEC8GfrscZmM1pzAXN/YCE8AwKWbZSisNP/UeKVGh+u55QCsk4EoEwsxPtIbALD7GpUxE0KIPatWaXHnJ8fw9bF0HE0ugkbHYmZfP8zo6wuRUIBpffwAAL+czUZiXiVKqk0z2fgBKl0s+5DDMEynni7Nrb1Wo6OECkK6MQogkib9eSkXBZUqeDtLMbu/PwBgcKgxgGiHGYhJxuBeT2/znrwzDMOXMdMk5qb9dfkWTqYV48XfLiPTGAAipK1uVSih1OghEjAIcnOw6GOFe8kxb3AgAOCtXQkdHj6SkGebASocX4UMfQIUYFngUKL5sxCv5ZZDo2PhKZcg0MLvDYebxrznap5Fh8MQQgjpmMNJhcgoroGnXIIXpvXGz48Pxyf3D+SrgqbGGPraHk0uwtQPjmD0Wwf4nscA+IBiZw6ydWUKmQhCgeG9pEnMhHRfFEAkjWJZFl8dTQMALBoRConI8FEZHOIOwHAiaW9Xn5ILjBmIZhygwuECAjSJuWlcCblKq8e/t12lk33SLunG/ofBHo5W6SP4j4kRkIoEOJtZir870DuwVl03xKm3jTIQAWBCpOEE7aAFAogXssoAAAOC3MzaJqI543p7QSISIKO4Bon5NMiKEELs1WFjafKdAwKwbFxPDOvhYfK3on+gK2L86y6wVat1eHLTOZxMLUZZjZoPSrk5dZ0JzF0JwzBwdeDKmKkPIiHdFQUQSaNOpBYjIa8SDmIhHhgWzN8e6OYAb2cpNDoWl4y9sOyBWqtHRnENAEMPRHOrm8RMAcSmpBTUlXcfSynC9otUykzaLq3I2P/QwuXLHF8XGZaMDAMArNuTCF07h3Uk5Vfy0+rNOcSprSYYS36PJBVBrdWbdd/ns4wDVEJczbrf5jhJRRjTy9DbcdcVKmMmhBB7xLIsDicZAohjI7wa3UYgYPDHilG4umYqDj8/DlKRAAl5lVjw1SnErT3AV/l0tQEqXQnXB5EyEAnpviiASBr1tTH78N7BgSalBAzD2GUZc0ZxNXR6Fs5SEXwU5j9550uYb1VSZl0TuADijL6GksPXdtxAaTVdoSRtw09gtuAAlds9OTYcCpkIifmV7e7haesBKpx+AS7wlEtQpdKapa9jfVwG4sAgy/c/rK9uGjMFEAkhxB6lFVUjr0IJqUiAoWHuTW4nFDCQS0UI8XDCxiVD+bLmWo2Ov0hEAUT7xZ0TllEGIiHdFgUQSQMpBZU4mFgIhgEeNmbm1BdrLGM+Z0cBRG64SU8fuUVK63p6yyEUMCiv1SCvQmn2/Xd2xVUqlFSrwTDAm3P7IcJHjpJqNdbuumHrpZFOJs3YD6mHp/UCiC6OYiwb3xMA8N6+JKi0bW/PwPU/tGX5MmDI8Bjf25CF2JGS7NvdKq/FrXIlBAzQP8jFbPttjUlR3hAJGCTkVZr0yyKEEGIfcstqAQChHk6QiVs3QTku3APrHxqMRXEhAICsEkMlkZsjlTDbKzeaxExIt0cBRNLAN8fSAQCTo3wQ2shJ/GDjJOZzmaXQt7Pcz9yS8i3X/xAwTAMNN2ZEURlzQ1z2YaCbAxQyMf57d18AwC9nb+JUWrEtl0Y6mXRjCXOYFQOIALB4RCh8FFLklNVi06msNt8/4ZZtJzDXNzHKGEBMyDdbxjSXfRjpq4CjRGSWfbaWq6MEceEeACgLkRBC7FFhpQoA2tXCIybA9KKUmxNlINorLgOReiAS0n1RAJGYKKpS4bfzhhK+x8b0aHSbaH8FHMRClNdqkFpY1eg21sYFsHqZeQJzffXLmImpFOPnoKeXIYA7ONQd9xt7Z/7ftivtyugi3Y9So8PNUkMWQw8v6/RA5MjEQjwzKQIA8OnBFFQqW391nWVZvoSZ+z1hS6N6eUEsZJBZXMNndHbU+Uzr9z+sb6pxGvPuqxRAJIQQe9ORAGIf/9sCiFTCbLe4DMR39iYix5h1SgjpXiiASExsOpUJtVaP/oEufKbh7cRCAV/CZi99EPkJzD6WCzrUBRApA/F2fAl5vQzQF6dFwstZirTCanx2MNVWSyOdSFZJDVgWcJaJ4Cm3/gnEvbGB6OHlhJJqNb46ktbq+xVWqlBao4GAMf0ZsBW5VIThPQwZewcTzFPGfME4NMva/Q85U6J9wDDAxewy3Cq3/EkL9bolhJDW60gAsZePHIJ63YfcKQPRbgW5OwIAWBaY/fExXM0pt/GKCCHWRgFEwlNqdPj+ZCYA4NHRPZrtJTjY2AfxbIbtA4ganZ7vi9XLAhOYOVxpIgUQG+IyUetngLo4iPHK7GgAwOeHUk2mNBPSmLRCbgKzk0V6mbZEJBTg+Sm9AQBfH0vnT4hacsPY/zDMs/W9nyzNnH0Q1Vo9rhhPEgYGu3Z4f+3hrZAhNtgQvNx7Ld/ij/fqXwn4MVWAoqrWfQYIIaQ7KzT+rvSStz2AKBYK+CzziZHe/LBGYn/mDwnG2/f0Q6SvM0qq1Vi3J9HWSyKEWBkFEAlv+4UcFFerEeDqgOnGqZdNiQ3l+iCad8pne2QWV0OjY+EkEcLfRWaxx4k2ZiCmF1VDqaGS3Pq4DMTw27KvZvb1w/jeXlDr9Pi/bVfspmcmsU/8ABUrly/XN62PL/oHuaJGrcMnB5JbdZ9EO5nAXB/XBzE+owTltR1rdn79VgXUWj1cHcVW701ZHzeN2dJlzNdzK7D5TDZOFQiQWkhDWwghpCUdyUAEgI8WDMTl1VPwzeIhVu+zS1pPIhJg3uAgfDh/IADgdHoxnRMR0s1QAJEAAPR6Fl8bh6csGRkKkbD5j8agYDcwDJBRXNPqLB1LqV8+a8msJS9nKTycJNCzdUNbCFCprJtMfXv5JsMwePXOPnAQC3EmvQRbzmXbYomkk0gzBmtsGaRiGAYvTjNkIW4+k4Ws4poW72NPA1Q4IR5OCPdyglbP4mhyYYf2dSHLkGk+MMjVJpmhHC5D5XR6MUqqLdPAnWVZrPnzGvQsMMBDj2Fh7hZ5HEII6YxYlsWZ9BIUVBqO+7KKa1Ct0vLnAt7tDCCKhQIoZDR9ubOI8JHDRyGFUqNHfIbtk0kIIdZDAUQCADicXIiUgirIpSLMGxLU4vYuDmJEGMtVz9m4D2IyN0DFguXLgCGwEOlHZcy340qTvZ2lcHFoePAX5O6IlZMNwyn+uzOBSgJJk9L5DETbBRABYES4J8ZEeEGjY/HuvpbLc7gS5kg7GKBS38QoHwDAgQ6WMZ83TmAeFGzbsrIgd0fE+CugZ4H91y1TxrzzSh5Op5dAKhLgzhC9RR6DEEI6qzPpJZi3/iSGvvE37v7sOMasO4hHvz2Lgg5mIJLOhWEYjO7lBQBYsiEee6/RgDNCugsKIBIAwNdHDQMD5g8JavUVwEEh9lHGzAcQrTC8IMqXJjHfjp+A3cwAmyUjQxHtp0B5rQav77huraWRTobrgWjLDETOC1MNWYi/X8zFtdymm4RrdHqkGn8G7CkDEQAmRBrKmA8lFULXgfYBfAaijQOIADDNmIW46+ots+9bqdHhvztvAAAeHx0KdzoPJoQQE/Un714wXlw6mVbMt8qgAGL3Mbu/PxgG0OpZPP79OTz780WUWqg6gBBiPyiASHA9twLHU4ohYIDFI0NbfT9uSrOtJzEn51t+AjOHJjE3xAUQezbTt04kFGDtnL4QMMD2i7kdLqkkXU9ptRqlNYYTEHsIIPYJcMHs/v4AgLd3N52FmF5UDbVOD7lUhABXB2str1ViQ9ygkIlQUq3GReMU5bYqqFTiZmktGAboH+Ri3gW2w/S+hgDi8ZRiVCg71tvxdusPpyGnrBb+LjI8NirMrPsmhJCuoFpt6HcnYIAnx4WbfE8sZBqtRCFd09gILxx6bhyWjukBAQNsu5CDUW8dwIbj6Sbb6fQs/r3tCl789TJOp5eA2qET0rm1KYC4du1aDBkyBM7OzvD29sZdd92FxETTE6tx48aBYRiT/5544gmTbbKysjBz5kw4OjrC29sbzz//PLRabcefDWmXr48Zsg+n9/VDoJtjq+/HTUm7mlNuswa6Wp2e75tWfwKwpdQvYWZZ+gsI1AsgtlBC3j/IFQvjQgEA/952FbVqarpM6nADVPxcZHbTQP2fkyMgEjA4nFSIk6nFjW6TYCxfjvCRQyCwXX/AxoiFAow1TmM+kNC+kl8uwyTC2xnOdtCfqqe3M8K9nKDW6XEwoeMTpjk5ZbX4/HAKAGDVjCg4SOxjmjYhhNiTGpXhfO2ugQF4cVok1s7py3/Pz8XBpn1yifWFeDhh1Ywo/PrkCET5KVCt1mHNn9fx1I8XkGAcMHc2owQ/nM7Cz2ez8eD/zuKrBMpfIqQza9NP8OHDh7F8+XKcOnUK+/btg0ajwZQpU1BdbTql8LHHHsOtW7f4/95++23+ezqdDjNnzoRarcaJEyfw7bffYuPGjXj55ZfN84xIm+RXKPHnpVwAwGOje7TpvsHujvCUS6HRsbiS03SJnyVlldRArdPDQSy0SvZPT285RAIGFUotcsuVFn+8ziC5FRmInOem9oafiwxZJTX4qJUTbkn3YC/9D+sL9XTCgqHBAIC3dic0etEgwZiNbG/9DzkTIg09iv5uZx9ELoA4MNjVTCvqOG4a8x4z9lxau/MGlBo9hoa5Y1Y/P7PtlxBCuhIuA9HJeKHvjv7+mBLtg4mR3vjv3X2buyvpwgYFu2Hn06PwgnEI3Z+XcjH742N4b28izhnboHDZqUnlFGQmpDNrUwBx9+7dWLx4MWJiYtC/f39s3LgRWVlZOHfunMl2jo6O8PX15f9TKOpOrPbu3Yvr169j06ZNGDBgAKZPn47XXnsNn376KdRq6ptgbd+eyIBGx2JwiBsGBLm26b4Mw9SVMWfYpoyZD155Wyf7RyoS8pOGE6iMGUqNDtmlhim1rSkhl0tFWHNHDADgqyNp/NVJQuyp/2F9T03sCQexEBezy7DnWsMsPi4DMcrO+h9yxkZ4Q8AY1lm/d1VrnTce+Nt6gEp902IMAb6DCYVmyX4/nVaMHZdvQcAAr8yOpgwaQghpQrUxA9FRasjSdpKK8OXCwfhm8RCM6uVpy6URG2MYBsvG9cTvy0diUpQ3NDoWHx1I4dvAcD2MtSzTob7MhBDb6lAOcXm5IevM3d3d5PYffvgBnp6e6NOnD1atWoWamhr+eydPnkTfvn3h4+PD3zZ16lRUVFTg2rVrHVkOaaMatRY/nM4CADzaxuxDDlfGbKtBKilWHKDC4QYlUB9EILWwCiwLuDqK4eEkadV9psT4YmqMD7R6Fqu2XoGeDiII6mUgelrvZ7k1vJ1leHS0oR/euj0J0OpMJ/MmGgOIvX3tMwPR3UnCB//aWvKr1elx+WYZAPvKQOwToECAqwNqNTocSepYP1WdnsXqPw2DneYPDUaMv+37PBJCiL2qURsCiE520mqE2J/+Qa74auFgvHtvf5PbB9Q7jqi1UesrQkjHtfu3v16vxzPPPIORI0eiT58+/O33338/QkJC4O/vj8uXL+PFF19EYmIitm7dCgDIy8szCR4C4L/Oy2u8HEmlUkGlUvFfV1QYAjcajQYajXmbqNfH7duSj2FLP5/JQnmtBsHuDhjXy71dz7N/gCGYdi6zFGq1usXMDXO/pgm3DEHsHp6OVnufInwMGVLXcsrt5rNhq89qovH17+nl1KY+pi/N6I1jKUW4kFWG706k4YFhwZZaYrt19Z9/W2juNeUmGQe7Se3uNV8SF4xNpzKRWliNX+IzcW9sIACgolbDZ/WFe8hstu6WPqvjIjxxNrMU+6/n4b5Y/1bv91puBZQaPZxlIgS72tf7MjnKCxtPZmHXlVyMj/Bo935+jM/GjVsVUMhEeHp8jwavpaWfsz29poQQ0pJqlSHw40h9YkkzGIbB3NhAbDqdybdC6RvgAoYBWBaoVetgP3UNhJC2aHcAcfny5bh69SqOHTtmcvvjjz/O/7tv377w8/PDxIkTkZqaivDw8Nt30ypr167FmjVrGty+d+9eODq2fuhHe+3bt8/ij2Ftehb49KIQAIMhiirs2b2rXfvR6gExI0RpjQYbt+6CTyvbEJrrNT2fYngOZVkJ2Lnzhln22ZLKMgaAEOdS87BzZ45VHrO1rP1Z3Z0lACCAuLYEO3fubNN9p/kx+C1DiDd33YDg1lW4tC6B0eq64s+/rd3+mupZIK3Q8LOceTUeO1Nss67mjPVisD1TiLd2XoM49zIkQiC1AgBEcJOwOHbQ9p+Tpj6rwhoAEOF4ciG2/7kTrT3vO5pn+F0XIFVjdzv/RliKwvja776Si9HSbAjbUU9RowXeumD43E30VeH04f0NtrH0z3/9Cg1CCLF3XAaiXEoZiKRl/QNd+QBiT285HMRC1Kh1qKEMREI6rXb99l+xYgV27NiBI0eOIDAwsNlthw0bBgBISUlBeHg4fH19cebMGZNt8vMNfaV8fX0b3ceqVauwcuVK/uuKigoEBQVhypQpJv0VzU2j0WDfvn2YPHkyxGLbT580p33XC1B06iIUMhH+8+AEOHXgQOCn/HjEZ5RCHtoPM2Kb/zyY8zXV6Vm8EP83AD3mzxiLEHfLB5MBYEilCp/fOIxCFYPxk6baxbROW31Wd/54EcgpwPjYKMwYEdKm+07Vs0j56gwu3SzHCWUAPr6rf8t3sqKu/PNvK029pjdLa6E9dRRiIYMH7poOoZ1NMwaAiRodTn94HLfKlShyi8ajo0INLSCuJaB/qBdmzBhks7W19FllWRabMo8ip0wJRcQQTOjt1ar9Hvj1CoBbmDSwJ2ZM7GnmVXeMTs/ih7cPo7haDbfIYRjVs+1ZiK/vTEC1Ngs9vZzwxuI4iOtFIa31889VVBBCSGfAZyBSAJG0woPDg7HxRAaGhLpBJhbyAUSlmgKIhHRWbfrtz7IsnnrqKWzbtg2HDh1CWFhYi/e5ePEiAMDPz9D0PC4uDm+88QYKCgrg7e0NwHCFX6FQIDo6utF9SKVSSKXSBreLxWKrnNhb63GsaeNJQ+/DB4aHwFXesenFQ0LdEZ9RigvZFbh/eOteJ3O8prnF1VBp9ZCKBAjzUlgt6ODvLoanXIKiKjXSSpRtHj5jSdb+rKYWGbJnevu5tPlxxQDenNsPsz4+ht3X8nEkpQQTo3xavJ+1dcWff1u7/TXNKisDAIR6OEEmtc9UVLFYjJWTI/D8r5fxxZF03D88FEmFhs9/tH/bP/+W0NxndUKkD74/lYnDycWY2qd1ZcyXbhpaFAwO87CL51efGMDUPr7YfDoL+xMKMT6q8QuQTUnOr8Sm09kAgFfuiIGjrOExBmD5n397e10JIaQ5dT0QbX/xnNi/nt7OOPL8eCgcDCEHB4kQqAZlIBLSibWp6Gf58uXYtGkTNm/eDGdnZ+Tl5SEvLw+1tYYeUKmpqXjttddw7tw5ZGRk4I8//sDChQsxZswY9OvXDwAwZcoUREdH46GHHsKlS5ewZ88evPTSS1i+fHmjQUJifpeyy3AmowQiAYNFcaEd3l/dIBXrTmJOzjf0TAv3kls9YynKz5D52p0HqWh0emQYB1+0d4hNlJ+CH1Dx8u/X+Ol+pHtJt9MJzLebMygQET5ylNdqsP5war0BKvY5gbm+CVGGC3YHEwrAsi0PLiqpViOj2BAgHRhkn52KuImOe67lt2miI8uyeHXHdej0LCZH+2B0r9ZlZBJCSHdXxU1hpiEqpJWCPRzh6mi4OOwoNgSeaykDkZBOq00BxM8//xzl5eUYN24c/Pz8+P9+/vlnAIBEIsH+/fsxZcoUREZG4p///Cfmzp2LP//8k9+HUCjEjh07IBQKERcXhwcffBALFy7Eq6++at5nRpr09bF0AMAd/f3h6yLr8P64CZ9pRdUorlK1sLX5JBUYTt57+Vh/aisXQEzoxgHEzOJqaPUsnCRC+HXgc/TMxAgEuTsgp6wW7+1LMuMKSWeRxk1g9rKvCcy3EwoYPD81EgDwv+PpuJ5r+Pnnfh/Ys7geHnAQC3GrXIkbtypb3P5CluGCULiXE1wc7TNLbngPDyhkIhRVqXA+q/UXsPZdz8fR5CJIhAK8NDPKgiskhJCupcYY+HGSUgYiaTuZxBB6oAAiIZ1Xm0uYmxMUFITDhw+3uJ+QkJA2D1wg5pFTVoudV24BAB4Z3XIJemu4OkrQy1uO5IIqnMssxZSYtpWStVeKMQOxvdlvHRFpzDhqzYl4V5VinJrb01ve4vTt5jhIhHjtzj5YvCEeG46n464BAegb6GKuZZJOIJ0PINp3BiIATIryxuAQN5w1ZlxLhAK7z5wEAJlYiJE9PbH/Rj4OJOQj2r/5oCfX9HxgsH1mHwKARCTApCgfbL2Qg91X8zAk1L3F+yg1Orz+l2Hg1qOjwxDiYf/vHSGE2ItqykAkHcBnIFIJMyGdVjvmFpLObOPxdOj0LEaEeyDG33xBGluUMScbA1i9fKxfPsiXMOdVtKocsCviS8jNEMAd19sbs/v7Q88Cq7Zdhlan7/A+SeeRVmgMIHaCQBzDMHhxeiT/dbi33GT4hj2baCxj/juhoMVtuYy+QXYcQAQMfRABYPfVvFb9Lv7mWDqySmrg7SzFsvH2NRiGEELsGcuylIFIOoQbPEkBREI6r85x1kPMolKpwU9nDE3jHzVT9iEnNsSQ+XHWSgFEvZ7lM+BskYEY7iWHWMigUqlFTlmt1R/fHqQUcq+/eQK4L8+KhkImwtWcCmw8kWGWfRL7p9To+J8hey9h5gwJdcfESEMwLsrP/vsfcsb3Nqz5YnYZipppN6HTs7iUXQYAGBjsaoWVtd+YXl5wEAuRU1aLa7nNt5TIr1Di04MpAIB/TY+EnKaIEkJIq6l1emiN/Wad6PcnaQdHseFzU1OvhPnn+Cz8cDrTVksihLQRBRC7kZ/js1Gp0iLcywnjIrzNuu/BIYYslSs3y6G0wlWlnLJa1Gp0kAgFCHZ3tPjj3U4iEiDcGOxo6aS1q+IyEHuaKYDr5SzFv6Yb+pGtP5JGWYjdBFe+7OIghpud9tprzBt398XiEaFY0Ymy2HxdZIjxV4BlgUOJhU1ul1xQiWq1Dk4SISJskOHdFg4SIcb1NgxB2X01r9lt39qVgBq1DgODXXHXgABrLI8QQrqMGlXd8T1XikpIW9zeA1Gp0eH/tl3Fv7ddbfbCJiHEflAAsZvQ6vTYcDwDAPDIqB4QmHlqcYiHIzzlEqh1elzNKTfrvhuTbByg0sPLCSIblQ8ODTNkXf54Jssmj29Lej2LtCLzZ4DeExsIN0cxCitVOJZSZLb9EvtVv/9hR3ppWpuviwyr74jpNFmTHC5z8mAzZcznM8sAAP2DXK0+4b49pnFlzNeaDiCezyrF1gs5AIDVs2PM/jeQEEK6Om4Cs1QksNmxN+nc6nogGpIESmvU0BmzWlONlWWEEPtGv/27id3X8pBTVgt3JwnmDDJ/5gXDMHyvLGv0QeSy32zR/5DzyKgwCAUMDiUW4vLNMputwxZyymqh1OghEQkQZMYMUIlIgDv6+wMAthlP9knXlmYshe8Mg0i6gglRPgCAI0mFUGsbz/LlJjDbe/kyZ0KkNyRCAVIKqpBS0HCwlV7PYs0f1wAA98YGon+Qq5VXSOzBm2++CYZh8Mwzz/C3KZVKLF++HB4eHpDL5Zg7dy7y8/Ntt0hC7Fhd/0MqXybtc3sPxNJqDf+9NOMFZUKIfaMAYjfAsiy+OpoOAHhweAhkFio74AapWKMPYrIN+x9yQjyccKcx2PXR3yk2W4ct8Bmgnk5mz1CaMygQALDnWh4qlZoWtrZveeVK5Fcobb0Mu8YdMIZ3sky+zqpfgAs85RJUqrQ4m1HS6DadZYAKx1kmxsieHgCAPdcaBn9+PX8Tl26WQy4V4flpva29PGIH4uPjsX79evTr18/k9meffRZ//vkntmzZgsOHDyM3Nxdz5syx0SoJsW/Vam4CM5Uvk/ZxMJ6DcsHoslo1/z3ugjIhxL5RALEbyKtQ4lJ2GYQCBg8ND7HY43CDVM5nllp8MnFyviGAZcsAIgAsn9ATDAPsv5GP692oFyI3wMZc/Q/r6xfognAvJyg1euxqoaeZPUvMq8TEdw9h0nuHcbO0xtbLsVvcBGbKQLQOgYDhh6k0No25vEaDVON7MqATZepNqzeNub5KpQZv704EADw9sSe8nWVWXxuxraqqKjzwwAP46quv4OZWFxQvLy/HN998g/feew8TJkxAbGwsNmzYgBMnTuDUqVM2XDEh9onrgegkoQxE0j58BiIXQKypSxTgjj0IIfaNAojdAFfuG+rhCC9nqcUep0+AAhKRAMXVar6vmSWwLFuXgehj2wBiuJccs/oZshA/OZhs07VYk7kHqNTHMAyfhbjtfOcsYy6v0eDx78+iWq1DpVKLF369DL3eskH1zohlWf6Kcw8vCiBay8QoQwDxQCMBxAvZhuzDUA9HeMgt9/fC3CZF+UDAAFdyypFdUhew//hACoqqVAjzdMLiEWE2XCGxleXLl2PmzJmYNGmSye3nzp2DRqMxuT0yMhLBwcE4efKktZdJiN3jMxCllIFI2sdBbFrCXD+ASBmIhHQOdAmpG7Bktlh9UpEQ/QNdEJ9RirOZpRYbLpBbrkSNWgexkEGIh+2DDivG98Sfl3Kx62oekvIr7X5qqTmkFHIl5JZ5rncNDMC6PYk4mVaMm6U1CHSz/qTt9tLpWTz10wVkFtfA30WGkho1TqQW44fTmXgoLtTWy7MrJdVqVCi1YBgg1A5+lruLUb28IBYySC+qRlphlcnv6gtZZQCAgZ2kfJnjIZdiaJg7TqWVYM+1PDw6ugfSCquw4bihfcd/ZkVBIqJrpt3NTz/9hPPnzyM+Pr7B9/Ly8iCRSODq6mpyu4+PD/LyGs9+V6lUUKnqJoVWVBgqDzQaDTQay7Xc4PZtyccgbdfd3pfSKkNLFieJ0O6fc3d7bzoLLvZcozL8ziyurOW/l1VSg6paFaT0t9rq6OfFPlnzfWnLY1AAsRvggj2WDiAChjLm+IxSnMsoxbzBQRZ5DK58OczTCWI7mALX29cZ0/v4YtfVPHxyIAUfLRho6yVZFMuySLFgBiIABLg6IK6HB06mFeP3i7lYPr6nRR7HEt7Zm4gjSYWQiQX4etEQnE4vxpo/r+O/OxMwJsLLLoLe9oLLVPZ3cbBYb1bSkFwqwrAwDxxLKcKBhALTAGJ2GYDOM0ClvmkxviYBxNf/ugGNjsW43l6YEOlj6+URK8vOzsY//vEP7Nu3DzKZeUrX165dizVr1jS4fe/evXB0tPyFrn379ln8MUjbdZf35XgOA0AIVVkhdu7caevltEp3eW86i6Riw2cot7AEO3fuxPkMAbiCSD0L/LB9N3w7T85Al0M/L/bJGu9LTU3r221RALEbsFYGIgAMDuEGqTTenN8cUgosm/3WHism9MSuq3nYcTkXz0zqZbHsS3tQUKlCpUoLoYBBqKfl/srfPSgAJ9OK8dv5m1g2LhwMY95hLZaw43IuPj+UCgB4+57+iPZXINLXGbuv5uF0egme33IZPz0+HAIzD57prLj+h1S+bH0TIr35AOKjo3sAMEwrvtDJBqjUNyXGF6v/vI6zmaX45Ww2DiQUQCRg8J9Z0bZeGrGBc+fOoaCgAIMGDeJv0+l0OHLkCD755BPs2bMHarUaZWVlJlmI+fn58PX1bXSfq1atwsqVK/mvKyoqEBQUhClTpkChUFjsuWg0Guzbtw+TJ0+GWCy22OOQtulu78vFXYlAVib69Q7DDDsfSNXd3pvOQnYjD/9LugypkzNmzBiBI9uuArdy+e8HRMViagxd8LM2+nmxT9Z8X7iKitagAGI3wPWU6Oll+YBbrDGAmFpYjdJqNdycJGZ/jCRjBqI1AqKtFePvgklR3th/owCfHkzFu/P623pJFsP1Pwxxd4RUZLmssel9fPHy71eRVliNyzfL0d/OBzrcuFWB57dcBgA8PqYH7jBO6BYIGKy7pz+mfXgEZzJKsOFEBh4ZRb3YgLoJzD1ogIrVTYzyxqs7ruNMegkqlBooZGKkFVWhUqmFTCxAb1/7uUDTWv6uDugf5IpL2WVYtfUKAGDJyFCa8N1NTZw4EVeuXDG5bcmSJYiMjMSLL76IoKAgiMVi/P3335g7dy4AIDExEVlZWYiLi2t0n1KpFFJpw96gYrHYKidd1noc0jbd5X0pMfar83Fx6DTPt7u8N52Fs4Ph96dSo4dYLEZ5raEXooAxZCBmlirp/bIh+nmxT9Z4X9qyf9vXfxKLKqtRo6hKDcA6WT5uThKEGx/nXGapRR7j+i1DhNzWA1Ru99SEXgCA7RdzkFXcdafuphRYJ4DrLBNjaowhC2Tr+ZsWfayOKqtR4/Hvz6JWo8PoXp54YarplflgD0f834woAMDbuxOoUbQR9zrQBGbrC/FwQriXE7R6FkeTigAA5zPLAAD9Al3toj1Ee0wz/s7Q6Vl4yiV4amIvG6+I2IqzszP69Olj8p+TkxM8PDzQp08fuLi44JFHHsHKlStx8OBBnDt3DkuWLEFcXByGDx9u6+UTYneKjecTnp1owBaxL46S24eoGD5TUX6GDO5UOj4mxO51zjME0mpcua+/iwxOUusknA4OcQcAnLVAAPFAQj6u5lRALGT4bEd70T/IFWMjvKDTs/jsUIqtl2MxyVYsieemMf9xKRdqrd7ij9ceWp0eT/14AdkltQhyd8DHCwZC1Ejw5YFhwRjV0xMqrR7PbbkEHU1l5nsgduWSf3s2McpQJvR3Qj6AugnMnbH/IWdan7rS0+en9oZCRlfSSdPef/99zJo1C3PnzsWYMWPg6+uLrVu32npZhNiloirDACEKIJL24qYwV6m0UGp0KKs1ZLVy53RcaxtCiP2iAGIXxwUQw61Y7hsbavgjcM7MfRDVWj1e23EDAPDwyDD4uTiYdf/m8PREw7CP387fxM3SrpmFyPegtEIG6MhwD3g5S1Fao8GhxAKLP157rNuTiKPJRXAQC/HlQ4Ph6th42T7DMHjrnn5wlopwPqsMXx9Ns/JK7YtOzyLTmKlLGYi2MSHSGwBwOLEQOj3LZyAODLKvizNtEebphKcn9MTiEaG4N9Yyg7xI53Xo0CF88MEH/NcymQyffvopSkpKUF1dja1btzbZ/5CQ7o4CiKSjvJwlkAhYVKt0mP3xMeSVGyZ717XAqgLL0gV2QuwZBRC7uFQrTmDmcINULt0sh0qrM9t+NxxPR3pRNTzlUqyYYJ9TeWND3DEi3AMaHYsvDqfaejkWwQ/lsUJPTZFQgLsGGHoJbruQY/HHa6s/LuVi/RFDIHDdvf34EoymBLg68AMd3t2XxE8U745ySmuh1ukhFQkQ4Gp/FwO6g9gQNzjLRCiuVuN4ShGSjO0JBnXiDEQAWDmlN1bfEUPDigghxEx0ehYl1cYSZmfz9zcn3YOzTIwlEXp4yiVILqhClUoLABgQ5AqhgEGlUosz6ZYbxEkI6TgKIHZxfAaiFUsEwzyd4OEkgVqrx9Wc1k/0aU5BpRIfHzCUBb8wrTec7bgs7Wljz61f4m/yV9a6ipJqNYqNB5Dh3tbJGuPKmP++UcD3SrEH13Mr8MKvlwAAT4wNx6x+/q26372DAzG+txfUWj3+ueUStDr7LM22tNSiuv6HFOixDbFQgLERXgCA9/cngWUNQW5vhczGKyOEEGJPSqrV0LMAwwDuTVRaENIa0W4sdj41AjP7+QEAZGIBfF1kmDsoAACw8pdLuFVea8slEkKaQQHELi7FBhmIDMNgUIh5y5jX7U5ElUqL/oEuuMcYULJXw3t4YGioO9Q6PdYf6VpZiFxAOsDVAY4S6/TUjPJTIMpPAbVOjx2Xb1nlMVtSWm0YmqLU6DEmwgvP3zY0pTkMw2DtnH5QyES4fLO8y2aqtoTrc0Ply7Y1McpQxnwhqwwA+N/dhBBCCIcrX3ZzlDTa55mQtnBzlODT+wdh0yPD8N3DwyAVCfHy7BiEejgip6wWC748BaXGfFVshBDzob8AXZhSo8PNUsMVHGsGEIG6MuazGR0fpHIpuwxbzhmm8L7SScrSnjL2Qtx8OgsFlV0nC9Ga/Q/rmzPQcFXSHsqYtTo9Vvx4HjdLaxHs7oiP5g+AsI2fSV8XGVbfEQMA+PDvZFzPNU+mbmeSbsxAtMZ0eNK0sRHeqP/xHRjkarO1EEIIsU85xvMJTzllHxLzGdXLE0PDDMM35VIRNj06DJ5yCTKKa3AqrdjGqyOENIYCiF2YoREt4OoohoeTdf/gD+YHqZR2qBmuXs9i9Z/XABiCSIOCO0d2zKienhgY7AqVVo+vj6bbejlmk2zskdbTylNz7xzgDwFj+DxlFNl2QttbuxNwPKUYjhIhvlwY2+TQlJbcPTAAk6N9oNGxeG7LJbudMm0pdRmINIHZltydJCa/VykDkRBCCCetsArTPjiCR787CwDwdqYWF8RyAt0c+QFvJ1MpgEiIPaIAYheWajxBD/eSg2Gsm7XXJ8AFEqEAxdVqftJqe2y/mIMLWWVwlAjx4vRIM67QshiGwdMTDL0QN53K5BtPd3a2ykD0VsgwupehV9tWG2Yh/n4xB18ZA8Lv3Nsfkb7ND01pDsMweOPuPnB1FOP6rQp8cjDFXMvsFNKNgWDKQLS9CcYyZolIgOgWBgERQgjpPr44nIqEPMPF40hfZzw+poeNV0S6uhHhngCAk5SBSIhdogBiF1Y3Ldf6GT5SkRB9A10AAGcz21fGXKXS4s1dCQCA5eN7wqeTNfYf19sLfQNcUKPW4ZtjabZejlnwnykrl8QDwJxBXBnzzQ5ltbbX1ZxyvPjbZQDAsnHhmNHXr8P79HaW4bU7+wAAPj2Ygqs55R3eZ2dQo9bilnHAUA/qgWhzs/v5w1kmwrQYX0hEdFhACCEEqFBq8OclQ+/pHx8bjt3PjMEY4+AtQiwlLtwDgOG4+1BigY1XQwi5HZ0pdGGpNgz2AHV9ENs7SOWzgykoqFQh2N0Rj4wKM+fSrIJhGDw1wdAL8dsTmXY1Qbg9KpUaPujT08vZ6o8/JdoXThIhsktq2x2Ubq+SajWWfn8OSo0e43p74Z9TWj80pSWz+vlhRl9f6PQsVv5yESpt128anWHMSnZ3krS7BJyYT5C7I+L/PQkf3DfA1kshhBBiYwUVSry0/Qre2ZOIWo0OvbzlGN7D3dbLIt2Ej0KG4T3coWeBJRvjkV3S/ko2Qoj5UQCxC7NlthgAxHZgkEpmcTXfO/ClmVGQiYVmXZu1TI72QaSvM6pUWmw4nmHr5XQIVxLv5SyFi6PY6o/vIBHyWX9bz9+02uNqdXqs2HweOWW1CPVwxIf3DWzz0JTmMAyD1+7sAw8nCZLyq/Dh/mSz7dtepRcZDgZpArP9kImFnWJAFSGEEMv65lg6Np3KwncnMwEA9w8LtnorJNK9fb1oCPxdZGBZIKes1tbLIYTUQwHELkqnZ/keY7YOICYXVLU5++71v25ArdNjdC9PTI72scTyrMKQhWjohbjheDoqlBobr6j9+P6HNvo8AcCcQYEAgB2Xb0GpsU6m3tt7k3EitRhOEiG+XDjYIsFTD7kUb9zdF4Ch39CFLOtmWFob3/+QAoiEEEKIXSm97Zh9zsBAG62EdFdyqQjextZVFbWd99yJkK6IAohdVHZJDdQ6PaQiAfxdHWyyBg+5lA8QnG9DQORociH2Xc+HUMDg5VnRnf6q5/Q+vujlLUeFUovvTmTYejntxk9gtmEAcViYOwJcHVCp1GL/jXyLP158IYMNJwxX4N+d1x8RPpYr3Z7Wxxd3DvCHngWe23LJagFSW+AzEGmACiGEEGJX6vfCXTA02CZVJ4QoHAyfu3IKIBJiVyiA2EVx2WI9vORmLbdsq7aWMWt0eqz58zoAYGFcCHpZMGBjLQIBgxXGXojfHEtHtUpr4xW1T6odZCAKBAzuGugPANh23rLTmK/lVuDnVMOvyBXje2Jan44PTWnJmjti4OUsRWphNd7dm2jxx7OVjGIuA9F2nyVCCCGENFSjMlzAnBTljVdmR9t4NaS7cjEGECuUnfO8iZCuigKIXVRKoW37H3IGhxoDiK0cerHpVCZSCqrg7iTBMxMjLLk0q5rVzx9hnk4ordFg06lMWy+nXZKNAcRwG3+m7jaW0hxKKkRRlcoij1FUpcKyzRehYRmMi/DEs5Ot81l0dZTgzTmGUuavj6XjbEb7BhDZM5YF0owZiD0oA5EQQgixK9VqQ8BmXG/vTtuDnHR+CpkIAJUwE2JvKIDYRfEDVLxsG+yJDTFMbbuUXQa1Vt/stsVVKry/LwkA8M8pEV2qZEIoYLBsXDgA4KujaahVd67yVKVGx09B6+Vt26zQnt5y9A9yhU7P4o+LuWbfv1qrx7JN55FbroSXjMW79/S1ahbvxCgf3BMbCNZYylyj7lpXXis1QJVKC4YBQjwcbb0cQgghhNRTYzxGdZJS8JDYjoLPQKQAIiH2hAKIXVRqIZctZtsMn3AvJ7g5iqHS6nEtt7zZbd/dl4QKpRbRfgrMHxJspRVaz10DAxDk7oCiKjU2n8my9XLaJK2wGnrWUE7gKZfYejmYMzAAALD1gvmnMa/+8xrOZJRALhXhsUgdfwBjTf+ZFQ1fhQwZxTV4e3fXKmUuUBr+H+jmAKmITk4IIYQQe8K12nGUiGy8EtKdKWTUA5EQe0QBxC6IZdm6DEQbl5syDMP3QTzXTBnztdxy/GgMqq2+I8amfRstRSwUYNk4Qy/E9YdTO9WQjPol8fYw1GZ2f3+IBAyu5lQgKb/SbPv9/lQmNp/OAsMA78/rCx/bzB+Ci4MYb93TDwCw8UQGTqYW22YhFlBYa/j8UP9DQgghxP7wGYgUQCQ2pHDgSpi7ViUOIZ0dBRC7oMJKFSqVWggYIMzT9j3GuDLmpgapsCyLNX9cB8sCs/r5YWiYuzWXZ1VzBwXC30WGgkoVtpzNtvVyWi3FDgao1OfuJMH4SG8AwFYzDVM5lVaMNX9cAwC8MDUS4yK8zLLf9hob4YUFQ4MAGEqZ88qVNl2PuRQYA4j28LuJEEIIIaa4HoiOVMJMbMiFSpgJsUsUQOyCuGBPsLujXZQI1h+kwrJsg+/vuHwLZzJKIBML8H8zoqy9PKuSiAR40tgL8fNDqS32hbQXKQWGLD9bZ7TWx5Uxb7+QA52+4eeqLbJLarDsh/PQ6lnc0d8fT4ztYY4ldti/Z0Yj2N0ROWW1uHf9CWQV19h6SR3GlTCH0wAVQgghxO5wU5gpA5HYElfCTENUCLEvFEDsgvj+hzYeoMLpG+ACiVCAoioVskprTb5Xq9Zh7c4bAIAnx/aEv6uNakat6N7BQfB2liK3XInfzpu/h58l2EtJfH0ToryhkImQV6HEqbT2l/hWq7R47LuzKKlWo0+AAm/N7WcXZdoAIJeKsPmxYQjxcER2iSGImGzGku3WYlkWm09nYcXm8/jpTBYKKtqfDcllIPawk99PhBBCCKnDZyBKbJ+EQLovrgd5pZJKmAmxJxRA7ILsLdgjEwvRJ0ABADifWWbyvS8OpyK3XIkAVwc8PsY+sr4sTSYWYulYQxbiZ4dSoNHZdxaiVqdHelE1APv5TAGAVCTE7P7+ANDuQKxez+K5LZeQkFcJT7kUXz40GA52dsAc6OaILUvjEOEjR36FCvd9eQpXc5ofSGROKq0OL/52Gf+37Qp2XL6Ff229gqH//Rt3fnIMH/2djGu55Y1mFjdGq9OjSGX4N5UwE0IIIfZFp2eh1BiOS52klIFIbEchM3z+aIgKIfaFAohdUAo/gdl+gj2DQw19Dc9nl/G33SytwReHUwEA/zcjyu4CN5Z0/9BgeMolyC6pxfYL5unhZymZJTXQ6Fg4SoTwd7GvDNE5gwIBALuv5vFTA9vik4Mp2HU1D2Ihgy8eHGS3GbDeChl+fjwO/QJdUFKtxoIvT+FsRonFH7egUokFX57CL2dvQsAA9w0OQv9AFwDApZvleG9fEmZ+dAwj3zyAl7ZfwcHEgmaHA90sq4WeZeAgFsBXIbP4+gkhhBDSejXqumMpykAktsRlIFaptNDaebIFId0JBRC7IHvLQATAT2Kun4G4dmcCVFo9hoW5Y0ZfXxutzDYcJEI8NtqQcfnZodQO9/CzpOT8upJ4gZ1Nxx4U7IpQD0fUqHXYcy2vTffdcy0P7+1LAgC8flcfPshtr9ycJPjh0WEYGuaOSpUWD31zBkeTCy32eFduluPOT47jfFYZFDIRNiwZirfu6YffV4zCmf+biDfn9MWkKB/IxALkliux6VQWlmyIx6DX9uHx787il/hsFFaqTPaZXmTo4Rji4WR3nyVCCCGku+MmMAsFDKQiOk0ktsP1QAQMQURCiH2gvwxdTIVSg/wKw0m7vfRABIBBwYYAYnJhFWq0wOn0Evx15RYEDLD6jhi76TlnTQ8OD4GboxjpRdVYu/OG3ZYycz017WUCc30Mw+DugYYsxG1tyORMzKvEyp8vAgAWjwjFfUOCLbE8s3OWifHtkqEYG+GFWo0Oj2w82+bAaWv8fjEH93xxArfKlejh5YTty0dibL2p1N4KGeYPDcbXiwbj4stT8L/Fg3H/sGD4KKSoUeuw93o+XvjtMob+dz/u/uw4Pj2YgoS8Cr4Uvoeno9nXTAghhJCO4ao5HCXCbnlsTuyHRCSAg9iQBVtRSwFEQuwFBRC7mLRCwwm6l7MULg7iFra2Hi9nKUI9HMGyQFolg9f/SgAA3D8sGFF+ChuvzjacpCI8OzkCAPD1sXTct/4kskvsb8ouN7TDnkri67vbOI35WEoR8spbHu5RWq3Go9/Fo1qtw4hwD/x7Zuea/O0gEeKrhYMxvY8v1Do9lv1wHtsumGcYj07P4q3dCfjHTxeh0uoxvrcXti8f2ezAE5lYiAmRPvjv3X1xatVE7HhqFJ6Z1At9A1zAssCFrDKs25OIaR8cxTv7kgEAoR7U/5AQQgixN1wGIk1gJvZA4WD4HJbUqG28EkIIhwKIXQxfvmxH2Yec2BBDiei2DAES8qvg4iDGPyf3tvGqbGthXCg+vX8QnGUinM8qw4yPjmLnlVu2XpaJFDvOQASAYA9HDA11B8sC2y82n4Wo0emxfPN5ZJfUIsjdAZ/ePwhiYef7NSgRCfDxgoGYOygQOj2Llb9cwqZTmR3aZ6VSg8e+O4vPDxn6kj4xNhxfLxpiUkLSEoZh0CfABc9MisCfT43CqVUT8d+7+2JipDekIgE0OkOpfpSfc4fWSgghhBDz0etZVKm0dRmIUup/SGwvwsdwvHgqrdjk9kqlBsdTipBZXM3fptOzSMqvhN6O20IR0hXQ5aUuxh77H3IGh7rht/M3UaQ0lESsnBwBNyeJjVdlezP7+aFfoAue/ukCLmSVYdkP57FgaDBenhVt88Eyej1r158pzt2DAnAmowRbz9/E0jE9miy7eeOvGziRWgxHYxZfZ/78iYQCrLunH+RSIb49mYmXtl9FtUrLT/hui/Siajz23VmkFFRBKhLg7Xv64c4BAR1eo6+LDPcPC8b9w4JRq9bhcGIeDp86hylR3h3eNyGEEEI67khSIf7x0wWU1mhw5wB/AJSBSOzDlBhfHE0uwp5reXii3vHti79dxs4rhhY+cT08EBvihh2Xc5FRXINhYe54c24/hHlStQshltD5Um9Is+w52DPYOEgFAHp5O+GBYZ2j75w1BLk74pelcVg2LhwMA/x4Jgt3fnoMiXmVNl1XTlktlBo9JEIBgt3tt2/djL5+kIgESMqvwrXcika3+Tk+CxtPZAAA3ps3AJG+nb90XiBgsPqOGCwbZzioWrsrAe/uTQTLtv7q65GkQtz5yTGkFFTBVyHDlifizBI8vJ2DRIiJkd4Y7s3SABVCCCHETvxxKRelNRoAwO8XcwHQBGZiHyZH+QAwtMP59kQGkvIrUaXSYv/1An6bk2nF+ORgCjKKDW2gTqeXYNoHR7D/er5N1kxIV0cBxC4mrbBuYq69CfeSw8dZCgB4aUYkRJ2wdNSSxEIBXpgWiU2PDIOXsxRJ+VW445Nj+OF0ZpsCQubEBaTDPJ3s+v1ycRBjcrThIGPr+YZlzGczSvDS9qsAgGcnRWBan64z9ZthGLwwLRIvTDO0A/j4QApe3XG9xRIOlmXx9dE0LN5wBhVKLQYFu+KPFSPRL9DVCqsmhBBCiD3Ir2jYP9pJShmIxPZ8XWSYEGmoWnnlj2uY8v4RxL62D2qdHmGeTjjy/Hj8e0YUpkT7IMDVAW/O6YuRPT2g0urxj58u4FBigc3OoQjpquw3IkDaTK3VI9M4hMMeMxAFAgYbFsViRbRheAVp3Mientj1j9EY19sLKq0e/952Fct+OI9y49Vha+IzWn3s7/N0uznGYSp/XMoxmWidW1aLJzadg0bHYnofXzw1oaetlmhRy8b1xKt3xgAANhzPwL+2XoauiSCiSqvD879exut/3YCeBe6NDcSPjw+Ht0JmzSUTQgghxMYaG0BHGYjEXnxy/0D834xIDAl1A8MAKq3hGH9KjA+CPRzx2Jge+HLhYBz/1wTMHxqMjUuGYngPd1SrdVi8IR4/xWfb+BkQ0rVQALELySiuhk7PQi4VwUchtfVyGtXLR45eLnQlqCWecin+t2gI/j0jCmIhg11X8zDjo6M4l1li1XUkFxhKqO1xKM/txkR4wcNJgqIqNY4mFwIAatU6PP79WRRVqRHp64x37u3fpctnF8aFGp4jA/xy9iae/ukC1Fq9yTYFFUrM//IUfj13EwIGeHlWNN6+px+kIjpZIIQQQrqbPGMGoptj3dA06oFI7IWjRITHx4RjyxMj8NuTIzAszB0+CinuGxzU6PZioQBfLhyMu42JBR0dMkgIMdWmAOLatWsxZMgQODs7w9vbG3fddRcSExNNtlEqlVi+fDk8PDwgl8sxd+5c5Oeb9iDIysrCzJkz4ejoCG9vbzz//PPQarUdfzbdHJctFu4tb3KIBOk8BAIGj43pgd+eHIEQD0fklNVi3vpT+ORAcpOZZebGfaZ6dYIMRLFQgDuMzb+3ns8By7J48bfLuJpTATdHMb5aOLhblOTcExtonC7N4K/Lt7D0+7NQanQAgEvZZbjjk+O4kFUGFwcxvnt4GB4eFUa/LwghhJBuqEatRaXScA42Z1Agf3tMQOfvE026nkHBbvh5aRxO/98k9GgmuUEhE+M/s6IhYIBruRXINlboEUI6rk0BxMOHD2P58uU4deoU9u3bB41GgylTpqC6um6E+rPPPos///wTW7ZsweHDh5Gbm4s5c+bw39fpdJg5cybUajVOnDiBb7/9Fhs3bsTLL79svmfVTfEBRC+aOtWV9At0xY6nRuHOAf7Q6Vm8szcJD359utGeNebEsiyS7XgoT2PmGg9+917Pxzt7E/HHpVyIBAw+eyAWQXY8BMbcpvf1w1cLB0MmFuBgYiEW/e8MfjqThXvXn0RehRK9vOX4fflIjOrlaeulEkIIIcRGuPJlJ4kQz03pjQ/uG4A/VozEwrhQ2y6MkA5yd5JgWJihZdY7exNRWq1uclvqk0hI67UpgLh7924sXrwYMTEx6N+/PzZu3IisrCycO3cOAFBeXo5vvvkG7733HiZMmIDY2Fhs2LABJ06cwKlTpwAAe/fuxfXr17Fp0yYMGDAA06dPx2uvvYZPP/0UanXTP9ikZamFnSvYQ1rPWSbGB/cNwLp7+sFBLMTJtGJM//AoDiRYbsJYYaUKlUotBIxhiEpnEOOvQC9vOdRaPT49mAoAeGV2NOK6Yc/Ncb298d3DwyCXinA6vQT/2noFaq0ek6K8sXXZCIR2kveUEEIIIZbBlS/7uMjgIBHiroEBNEyNdBkPDA8GYJguHvfm3/hgf5JJn3QAyCiqxoBX9+GNv67bYomEdDodqucrLy8HALi7uwMAzp07B41Gg0mTJvHbREZGIjg4GCdPnsTw4cNx8uRJ9O3bFz4+Pvw2U6dOxZNPPolr165h4MCBDR5HpVJBpVLxX1dUVAAANBoNNBrLDZbg9m3JxzCn5Pz/b+/e46Ms7/z/v2cmk8k5IWcCSQhnEEGEghHPnG0tVna/am1rLavfttCtTVtb+m11cd0fru23Wlsq267VdtdT9Vt1tRSJqFAxIEdFTpIQCKecCDlNkskkc//+mGQ0hgCBmbnvSV7Px4OHmfu+c9+fua475p5Pruv6+NerK0iNtWzMkdamVnPzlGxNzknUvX/+UPsqm/SNp7fprivz9d3rRkgKbrvuO1EvScpLjZPd8Mnr9Z39Gyxi0ZSh+kXxQUnSrdOH69ZpORfULgPhXp06PFF/umuavvHHHapv9epb1xTo3tmjZbeb874GQptaEe0afOFqU/oMgJm6Z7NkU0QNA9AXJucoKcapR97Yr4+ON+qxNw+qeG+VfvaFiZpZkCqbzaafvfqRGlq9+v3fy/V/Pj/R7JABy7vgBKLP59O9996rWbNmadKkSZKkyspKRUdHKyUlpcexWVlZqqysDBzz6eRh9/7ufWeycuVKrVixotf2devWKS4u9NMSi4uLQ36Ni+UzpINVDkk2Hdu7TWvKzY7o7CKhTa3sn/KlV2XXxkq7nnrviIo/OKx/Ghfcdt140ibJoURfs9asWRO084ZacruUHO1QTpyhGY7D+tvfDl/U+QbCvfqDS6TGdmmY96DWrj1odjgDok2tiHYNvlC3aUsL6zIBME9lg3+ABglEDFTXjM3Q1WPS9dqHJ3X/qx9pz4lG3fa7zRqfnaiiuWP1wdF6s0MEIsoFJxCXLl2qjz76SO+++24w4zmj5cuXq6ioKPC6sbFRubm5mjdvnpKSQrfIr9frVXFxsebOnSun03nubzDRsdOt8m7+u5wOm75y8wJFOaxZYDuS2tTqvihp/f5qLX95j465vXquzK6//PMNio6ODsr5t7y2Vzp8TFdOGqUb540JyjnD5dZF/rVMLqY4CPdq8NGmoUG7Bl+42rR7RgUAmOFkQ6sk/xRmYKCy2Wz64pQcXTEyVY+9eVAv7ziu/ZVNuue/tvc4rr3Dp+goa36GBqzighKIy5Yt0+uvv66NGzdq+PBPKnZlZ2ervb1d9fX1PUYhVlVVKTs7O3DM+++/3+N83VWau4/5LJfLJZfL1Wu70+kMy4elcF3nYhw5fVqSNCItXrExvdvKaiKhTSPBgkuHaWx2suY/tlEHGuzaVN6geZNygnLuQ7X+kTHjhiYN6r7iXg0+2jQ0aNfgC3Wb0l8AzLT7uH85qrFZrJ+OgS8zMUb/35cu1Y/mj9dvN5TqPzYc6rH/lNujocmxJkUHRIZ+pdgNw9CyZcv08ssv66233lJBQUGP/dOmTZPT6dT69esD2w4cOKCKigoVFhZKkgoLC7V7925VV1cHjikuLlZSUpImTmTdgQtVGmHVchE8IzMSdGdhviTp4bUHei0OfKG4pwAAAAYmT0en9hz3j4K+PG+IydEA4ZMc59TyhRNU/L1r9O3rRgW21zZR0BU4l34lEJcuXar//u//1rPPPqvExERVVlaqsrJSra3+4e/JyclasmSJioqK9Pbbb2v79u266667VFhYqCuuuEKSNG/ePE2cOFFf/epX9cEHH+iNN97QT3/6Uy1duvSMowxxfqjAPLh9+9oCJUQZOlTbomc2H7no8512t6u22f9LdFQG9xQAAMBA8tHxRrV3+pQaH6281NCvKQ9YzZisRN23YLwuyfEviVbb7DnHdwDoVwLxiSeeUENDg6677joNHTo08O+FF14IHPPoo4/qC1/4ghYvXqxrrrlG2dnZ+stf/hLY73A49Prrr8vhcKiwsFBf+cpX9LWvfU0PPvhg8N7VIMRoscEtMcaphbn+kYePrT+o+paL+wtaaVdCelhKrOJdF1WsHQAAAGHW0OrV3w/W6MVtR/XitqNq83b22L+zwr/80eV5KRe1ZjQQ6dIT/IOYakggAufUr8yAYRjnPCYmJkarVq3SqlWr+jwmPz8/oqq6RoLuBCKjxQavwixDu9zxOljt1q/WH9QDN11ywecK3E8kpAEAACJCea1bj68/qL0nGlVR16LWTyUN/3tLhVZ9eaoOVjXrunEZ2lRaK0m6PJ/pyxjc0hL8BSgZgQicG0OLBoA6d7tOt3glSSMz4k2OBmZx2KSfLByvu/64Xf9VckRfuSL/ghPK3QnEMSQQAQAAIsL//q9t+riqOfA6JzlGQ1NitftYgz44Wq+r/v1tSdLdVxfo3a4E4twJWabEClhFRtcIRNZABM6NOuUDQHeyZ1hKrOKiyQkPZleNTtMN4zPV4TO0cs2+Cz7PQabEAwAARIyW9o7A89uDiy7Rfy+ZqXd/dIP+37eu1L1zx/Q49vd/L5e309DYrASNyUo0I1zAMrqnMJ9yMwIROBcSiAMA6x/i035y4wRF2W16c1+13j1Ye0HnKGMEIgAAQMT4uKpZhuFPhnytcISuGpMuu92/tuFVo9PP+D1fmJwTzhABS0pP9E9hrqhrUafv3Eu2AYMZCcQBgAQiPm10ZoK+ckW+JOmhv+7t9y9Ct6dDx+tbA+cCAACAtR2obJQkjc/uPaLwkpzkwNdx0Q798+wxum/BOC25qiBs8QFWNXyIvwr5zop63fTrd7X7WIPJEQHWRQJxACiroYAKevru7DFKjnVqf2WTXth6tF/f230/pSe4lBIXHYrwAAAAEET7K5skSePOkEB02G26fUaeJGn1V6apaO5Yffu60Yp3sfQRMD1/iB5cdImSYqK092SjfvjSB2aHBFgWCcQBgBGI+Kwh8dH67mz/eje/LD6gpjbveX/vwaru+4mCPAAAAJHgwFkSiJL0wE0T9fYPrtM1YzPCGRZgeTabTV8rHKGn7pohSapvOf/PTcBgQwIxwrW0M90UZ/bVwnyNTI9XbXO7Vr1ddt7fV1rTvf4hi2oDAABYnWEYgRGIZ5rCLEkxTocK0vnjMNCX5FinJKnV22lyJIB1kUCMcIdq3JKk1PhopcYz3RSfcDrs+smNEyRJf3i3XEfrWs7r+z4ZgUhCGgAAwOpqmj2qc7fLZuMPwMCFio12SCKBCJwNCcQI1z19eVQGf1FEb7MnZGrW6DS1d/q08m/7zut7ymqowAwAABApuqcvj0iLDyRBAPRPrNP/s9Pe4aMaM9AHEogRrjvZw2gxnInNZtNPPz9Rdpu0Znel3i+vO+vxbd5OHTnlH9XKPQUAAGB9gfUPsxh9CFyo7gSi5P9MBKA3EogR7pMRiCR7cGYThibp1s/5K+/96+t75TvLX9QOn3LLZ0hJMVHKSHSFK0QAAAD0w5FTbu072Sjp7BWYAZwfV9QnqRESiMCZkUCMcFRgxvkomjtWCa4o7T7eoJd3Hu/zuE+vf2iz2cIVHgAAQfXEE09o8uTJSkpKUlJSkgoLC/W3v/0tsL+trU1Lly5VWlqaEhIStHjxYlVVVZkYMXD+fD5D/7C6RAt/9Xcte3aHXtp+TFLfBVQAnJvdblOM058eYR1E4MxIIEawjk6fDndNN2UEIs4mI9GlpdePliQ98sZ+tbR3nPG47oQ0C3ADACLZ8OHD9fDDD2v79u3atm2bbrjhBi1atEh79uyRJH3ve9/Ta6+9phdffFEbNmzQiRMndMstt5gcNXB+apo9qmnySJJe//CkJMluk6bkppgYFRD5YrqmMTMCETizKLMDwIU7Utcib6ehWKdDw1JizQ4HFnfXrBF6ZssRHTvdqtUbDqlo7thexzCiFQAwENx00009Xv/bv/2bnnjiCW3evFnDhw/Xk08+qWeffVY33HCDJOmpp57ShAkTtHnzZl1xxRVmhAyct4q6lsDXt0wdpry0OM2ZkKUcPg8AFyXW6VC9vGpt95kdCmBJJBAjWFlXsmdkRrzsdqab4uxinA795MYJ+vYzO/S7jWW6fUauhib3fNAMJBCzSCACAAaGzs5Ovfjii3K73SosLNT27dvl9Xo1Z86cwDHjx49XXl6eSkpK+kwgejweeTyewOvGRv/6c16vV16vN2Txd587lNdA/5nZL+XV/jUPrxyZqn+/5ZJeMQ12/MxYUyT0S0zXOohNrR5LxxlMkdAvg1E4+6U/1yCBGMFKqcCMflo4KVszRqTq/cN1emTtAT1662WBfR2dPh2q7bqnmBIPAIhwu3fvVmFhodra2pSQkKCXX35ZEydO1K5duxQdHa2UlJQex2dlZamysrLP861cuVIrVqzotX3dunWKi4sLdvi9FBcXh/wa6L9w9UuHT9pYadOuU3YdafYPHDCaa7VmzZqwXD8S8TNjTVbul/ZWhySbNr63WTV7+y48ORBZuV8Gs3D0S0tLy7kP6kICMYIFRouR7MF5stls+ukXJuiLv9mkl3ce151XjtBlXevlVDAlHgAwgIwbN067du1SQ0ODXnrpJd15553asGHDBZ9v+fLlKioqCrxubGxUbm6u5s2bp6SkpGCEfEZer1fFxcWaO3eunE5nyK6D/gl1v5xuadc7B2r1h02HVetul9vToVZvz2mVs6aM043XFAT92pGOnxlrioR++ePx93W8ol6TL5umuRMzzQ4nLCKhXwajcPZL94yK80ECMYJ1T2EexQhE9MPk4Sm65fJh+suO4/rX1/fqpW8Wymaz6WDgfmJKPAAg8kVHR2v0aH8BsWnTpmnr1q361a9+pVtvvVXt7e2qr6/vMQqxqqpK2dnZfZ7P5XLJ5XL12u50OsPyoStc10H/hKJfTjV7NPuX76rJ07PoXUaiK1A8RZJGZCRwT5wFPzPWZOV+iYv2p0e8hiwbY6hYuV8Gs3D0S3/OTxXmCGUYhspq/BWYmcKM/rpv/njFOh3afuR0oHofFZgBAAOZz+eTx+PRtGnT5HQ6tX79+sC+AwcOqKKiQoWFhSZGCPi9c6AmkDz8h2nDNWNEqr4weajeuPca/ebLUwPH5Q4J/dR5YDCJcfrTI63tVGEGzoQRiBGqqtGjZk+HHHabRqTFmx0OIkx2coy+ee0oPfrmx3r4b/s1d2IWFZgBAAPG8uXLtXDhQuXl5ampqUnPPvus3nnnHb3xxhtKTk7WkiVLVFRUpNTUVCUlJek73/mOCgsLqcAMS/j7wRpJ0rLrR+sH88f12HfduE+mVY5I5zMAEEwxTockqdVLAhE4ExKIEao72ZOfGqfoKAaSov/uuWaknt9aoeP1rXry3fLAPTWKNTUBABGuurpaX/va13Ty5EklJydr8uTJeuONNzR37lxJ0qOPPiq73a7FixfL4/Fo/vz5+u1vf2ty1IDk8xl6t7RWknT1mPRe+xNcUVp779XydhhKjmW6IRBMsSQQgbMigRihSqubJEkjSfbgAsVGO3TfgnH63gsf6Ldvl6rT8FcaG5PFPQUAiGxPPvnkWffHxMRo1apVWrVqVZgiAs7NMAz957uHVNvcrvhoh6bmDTnjceOzQ1e0BxjMYqP9CcQ2pjADZ0QCMUKV1jDdFBdv0ZRhenrTYX1wrEGS5HTYlJ/KejoAAACh4vMZ+p8PTmhHxWldNTpd8y7J1t4TjfrJy7u162i9JOm7c8YwywgIM0YgAmdHAjFClVVTQAUXz2636WdfmKh/WF0iSSpIj1eUg4dVAACAUFm7p1L3vrBLkvSnkiMamRGvI6da1OkzFOO0a9n1o3X31SPNDRIYhLrXQGzz+kyOBLAmEogRihGICJbpXZX9Xv/wpMZmUYEZAAAgFI7WtajDZ+jNvVWBbTabdKjGPzBgwSXZevDmS5SZGGNWiMCgRhEV4OxIIEaghlavapo8kqSRGVRfw8X710WTlJsap3+YNtzsUAAAAAacjR/X6Gt/eL/HtufuvkLZyTHafOiUxmUn6vI+1jwEEB6xTv9MLBKIwJmRQIxA3dVys5JcSoqh+hou3pD4aP1owXizwwAAABiQutc2/LTpI4bI6bCrIJ0BAYAVUEQFODsWO4tAZUxfBgAAACJGdVObJCkpxj9+Y/Hlw+Vk3WnAUpjCDJwdIxAjUFnXCMTRGSQQAQAAAKurbvQvP/TD+eNUOCpdw4fEmhwRgM+iCjNwdiQQI1D3FGZGIAIAAADWV921fnlGYgzP8IBFBaYwU4UZOCPGzUeg7grMoxiBCAAAAFhedwHEzCSXyZEA6Ev3FOZ9JxtV1dhmcjSA9ZBAjDBt3k4drWuRxAhEAAAAwOoMw/gkgZhIAhGwqmEpsYruWpv028/sMDkawHpIIEaYw6fc8hlSYkyUMngAAQAAACytvsWr9k7/lEie3wHrykmJ1XP3zJQk7aw4LU8HayECn0YCMcJ8ev1Dm81mcjQAAAAAzqZ7/cMhcU65ohwmRwPgbC7PG6L4aId8hnTsdKvZ4QCWQgIxwnQnEFn/EAAAALC+6ib/WmqZiTEmRwLgXGw2m/LT4iVJR065TY4GsBYSiBGGCswAAACA9VU1tunNvVX6w7vlkiigAkSKEelxkqTDtS0mRwJYS5TZAaB/ymr8fwUZzQhEAAAAwJKK91bpf//XNvmMT7YVpMebFxCA88YIRODMSCBGkE6foUM1jEAEAAAArGzbkbpA8nBa/hBdPy5Dd80qMDcoAOdlRFrXCMRTjEAEPo0EYgQ5frpVng6foh12DR8Sa3Y4AAAAAM6gxeOv3vrPs8eoaO5Yk6MB0B/dIxAPMwIR6IE1ECNIaU2TJP/0hygHXQcAAABYkdvTIUmKj6bqMhBpcpL9g3WqGz0mRwJYC1moCEIBFQAAAMD63O3+BGKciwlfQKRJjnNKklq9nfJ0dJocDWAdJBAjSFm1fwj1KBKIAAAAgGW1tPuTDgkuRiACkSbRFSW7zf91Q6vX3GAACyGBGEFKKaACAAAAWF5z1xTmuGhGIAKRxm63KTnWPwqxoYUEItCNBGKEMAwjMIV5VEa8ydEAAAAA6Et3EZUEpjADESklLlqSVM8IRCCg3wnEjRs36qabblJOTo5sNpteeeWVHvu//vWvy2az9fi3YMGCHsfU1dXpjjvuUFJSklJSUrRkyRI1Nzdf1BsZ6Gqb29XQ6pXNJo3KYAQiAAAAYFWBNRApogJEpKSuEYj1jEAEAvqdQHS73ZoyZYpWrVrV5zELFizQyZMnA/+ee+65HvvvuOMO7dmzR8XFxXr99de1ceNG3XPPPf2PfhAp65q+PHxIrGKcPIgAAAAAVhWowswIRCAipXRPYWYEIhDQ799oCxcu1MKFC896jMvlUnZ29hn37du3T2vXrtXWrVs1ffp0SdKvf/1r3XjjjfrFL36hnJyc/oY0KAQqMDP6EAAAALA0d1cRFRKIQGRKiesegdhuciSAdYTkN9o777yjzMxMDRkyRDfccIMeeughpaWlSZJKSkqUkpISSB5K0pw5c2S327VlyxZ96Utf6nU+j8cjj8cTeN3Y2ChJ8nq98npD9xeB7nOH8hrn6+NK/3suSIuzRDwXykptOpDQrsFHmwYfbRoatGvwhatN6TNgYPJ2+tTe4ZMkxTOFGYhIjEAEegt6AnHBggW65ZZbVFBQoLKyMv3kJz/RwoULVVJSIofDocrKSmVmZvYMIipKqampqqysPOM5V65cqRUrVvTavm7dOsXFxQX7LfRSXFwc8mucy5Z9dkl2tVQe0po1ZWaHc9Gs0KYDEe0afLRp8NGmoUG7Bl+o27SlpSWk5wdgju4CKhJVmIFIldxdRIU1EIGAoP9Gu+222wJfX3rppZo8ebJGjRqld955R7Nnz76gcy5fvlxFRUWB142NjcrNzdW8efOUlJR00TH3xev1qri4WHPnzpXT6QzZdc7Hyj0bJHl08w1XaFr+EFNjuRhWatOBhHYNPto0+GjT0KBdgy9cbdo9owLAwNJdQCXaYVd0VL+XnAdgAcndRVQYgQgEhPxPYiNHjlR6erpKS0s1e/ZsZWdnq7q6uscxHR0dqqur63PdRJfLJZfL1Wu70+kMy4elcF2nL82eDlU2+qdwjxuaMiA+IJrdpgMV7Rp8tGnw0aahQbsGX6jblP4CBqbuAipxLqYvA5GKKcxAbyH/k9ixY8d06tQpDR06VJJUWFio+vp6bd++PXDMW2+9JZ/Pp5kzZ4Y6nIh0qKsCc1p8tIbER5scDQAAAIC+BAqoMH0ZiFjdRVQaKKICBPT7t1pzc7NKS0sDr8vLy7Vr1y6lpqYqNTVVK1as0OLFi5Wdna2ysjLdd999Gj16tObPny9JmjBhghYsWKC7775bq1evltfr1bJly3TbbbdRgbkP3RWYR2VSgRkAAACwspauEYjxjEAEIlagCjMjEIGAfo9A3LZtm6ZOnaqpU6dKkoqKijR16lTdf//9cjgc+vDDD/XFL35RY8eO1ZIlSzRt2jT9/e9/7zEF+ZlnntH48eM1e/Zs3Xjjjbrqqqv0u9/9LnjvaoDpTiCOJoEIAAAAWFpz9xRmRiACESs51j/zr6bJozZv5zmOBgaHfv9Wu+6662QYRp/733jjjXOeIzU1Vc8++2x/Lz1olXVNYR6dQQIRAAAAsLKW7inMjEAEItaItDjlJMfoREObXtp+TF+5It/skADTURYsAjACEQAAAIgM3VWYWQMRiFxRDrvuvmakJOnJd8tNjgawBhKIFuft9OnIqRZJrIEIAAAAWJ07sAYiCUQgkt00xV+jobzWLW+nz+RoAPPxW83iymvd6vAZiot2aGhSjNnhAAAAAPgMwzC062i93j5Qo8fXH5TEFGYg0qXEOgNfN7R6lZ7gOsvRwMBHAtHidlacliRNykmW3W4zORoAAAAAn7V6wyH9+9r9PbaNz04yKRoAwRDlsCspJkqNbR2qbyGBCJBAtLgdR+olSVPzU0yNAwAAAMCZfXS8IfD1L//XFE0enqzRmYkmRgQgGFLiotXY1qGG1nazQwFMRwLR4nZ0jUC8PG+IyZEAAAAAOJOaZo8k6fHbp+qLXeumAYh8KXFOVdRJ9S1es0MBTEcRFQtraPXqYFcFZhKIAAAAgDXVdiUQ0xOiTY4EQDAld62DeJoEIkAC0co+OFovScpNjVVGIustAAAAAFZU2+RPIGawRhowoAyJ8/9RoL6FKcwACUQLY/oyAAAAYG2ejk41tnVIEkUWgAEmJc4/ArGhlRGIAAlEC9tRUS+JBCIAAABgVaea/SOTouy2wHRHAANDStfPNGsgAiQQLcvnM7STEYgAAACApXWvf5iWEC273WZyNACCKbl7CjMjEAESiFZVVtOsprYOxTjtGj800exwAAAAAJzBJwVUmL4MDDRD4rpHILIGIkAC0aK61z+cPDxFTgfdBAAAAFhRbZM/sUACERh4UuKYwgx0IzNlUTuO1Eti+jIAAABgZTWMQAQGrOTY7inMjEAESCBa1CcVmFPMDQQAAABAL9Wt0s/+Z69+/sYBSVJ6YrTJEQEItu4RiEfrWnWwqsnkaABzkUC0oIZWrw5WN0uSLs9nBCIAAABgJe0dPj1f5tDzW48Ftk0cmmRiRABCISspRk6HvzjS4ifeU0enz+SIAPOQQLSgXUfrJUl5qXFMhQAAAAAs5Odv7NclK95UWZM/qXD/Fybqf5bN0hen5JgcGYBgS3BF6cVvXilJamzr0In6NpMjAsxDAtGCdhxh+jIAAABgJZ0+Q3Xudq16uyywbe6ETH3jqgJNHp4im81mYnQAQuWy3BSNzUqQJJWfcpscDWCeKLMDQG+B9Q+ZvgwAAACYbs3uk/rX1/fqZMMno49iHYa+dW2BiVEBCJf8tHh9XNWsI6fckjLMDgcwBSMQLcbnMwJTmKnADAAA0H8rV67U5z73OSUmJiozM1M333yzDhw40OOYtrY2LV26VGlpaUpISNDixYtVVVVlUsSwsi2HTumfn9vZI3l46/ThWvm5Tl06LNnEyACEy4i0OEnS4doWkyMBzEMC0WJKa5rV1NahWKdD47MTzQ4HAAAg4mzYsEFLly7V5s2bVVxcLK/Xq3nz5snt/mTq2fe+9z299tprevHFF7VhwwadOHFCt9xyi4lRw4oa27z67vO71OEzdOOl2Zo3MUtOh023TR8uZiwDg8eI9HhJ0mGmMGMQYwqzxXSvfzh5eLKiHOR3AQAA+mvt2rU9Xj/99NPKzMzU9u3bdc0116ihoUFPPvmknn32Wd1www2SpKeeekoTJkzQ5s2bdcUVV5gRNizoF28cUGVjmwrS4/V///EyxTjt8nT45JBPFR+YHR2AcBmR5k8glteSQMTgRQLRYlj/EAAAILgaGhokSampqZKk7du3y+v1as6cOYFjxo8fr7y8PJWUlJwxgejxeOTxeAKvGxsbJUler1derzdksXefO5TXQN/WflQpSfrJwrGKsvnU0eGTQ/SLldE31hTp/TIsOVqSP4F406//rpHp8frilKG6enRaRBdQivR+GajC2S/9uQYJRIvZUVEvifUPAQAAgsHn8+nee+/VrFmzNGnSJElSZWWloqOjlZKS0uPYrKwsVVZWnvE8K1eu1IoVK3ptX7duneLi4oIe92cVFxeH/BroqaVDqm7yf1yq279Va0p7H0O/WBd9Y02R2i8+QxqV6FBZk027jzdq9/FGvfrBSU1I8WnxCJ8yYs2O8OJEar8MdOHol5aW81/XkwSihTS0eFVa3SxJmpqXYm4wAAAAA8DSpUv10Ucf6d13372o8yxfvlxFRUWB142NjcrNzdW8efOUlJR0sWH2yev1qri4WHPnzpXT6QzZddBTdZNHfz9YK23do6HJMbrli9f02E+/WBd9Y00DoV8+f6OhQ7UtKq91671DdXp+61Htq7fr0X1Obfj+NUqOjbz3NRD6ZSAKZ790z6g4HyQQLWTnUf/05fy0OKUnuEyOBgAAILItW7ZMr7/+ujZu3Kjhw4cHtmdnZ6u9vV319fU9RiFWVVUpOzv7jOdyuVxyuXo/nzmdzrB86ArXdSD9ct0BrXqnTJ0+Q5I0Ljuxz7anX6yLvrGmSO+X8TnRGp+TooWTh+muWQVa9JtNavJ0qKrZq/Sk0I9GD5VI75eBKhz90p/zU6XDQpi+DAAAcPEMw9CyZcv08ssv66233lJBQUGP/dOmTZPT6dT69esD2w4cOKCKigoVFhaGO1xYiGEYevLd8kDyUJLGZiWaGBEAqxqZkaD0RP8fltyeTpOjAUKPEYgWsrO7gArTlwEAAC7Y0qVL9eyzz+rVV19VYmJiYF3D5ORkxcbGKjk5WUuWLFFRUZFSU1OVlJSk73znOyosLKQC8yBX0+SRu71nIiAvNXJHFQEIrXiXQ5Lk9nSYHAkQeiQQLcLnM7SrawTiVEYgAgAAXLAnnnhCknTdddf12P7UU0/p61//uiTp0Ucfld1u1+LFi+XxeDR//nz99re/DXOksJqyGrckf9IwKTZK+082adbodJOjAmBV8dH+lEozCUQMAiQQLaK0pllNng7FRTs0PptpEgAAABfKMIxzHhMTE6NVq1Zp1apVYYgIkaK81p9AHJkRr8dvn6rT7nblp8WbHBUAq0pw+VMqjEDEYEAC0SJ2HPFPX548PFlRDpamBAAAAMKtvLZZklSQHq+kGKeSYigqAKBv8S5GIGLwIFNlETsC6x8yfRkAAAAwwycjEBNMjgRAJCCBiMGEBKJFUIEZAAAAMM+L247qzX3VkqSR6UxbBnBuiTFMYcbgQQLRAhpavCqt9k+XmEoFZgAAACCsDMPQv/zPHklSjNOuSTnJJkcEIBJ8UkSl8xxHApGPBKIF7Dzqn748Ii1OaQkuk6MBAAAABpdT7na52/0JgE0/ukHJcax9CODc4l0OSYxAxOBAAtECmL4MAAAAmOf46VZJUmaiiz/oAzhvVGHGYEIC0QJ2dhVQmZpPAhEAAAAIt+P1/gTisCGxJkcCIJJ0F1FpIoGIQYAEosl8PkO7AiMQU0yNBQAAABiMukcgDkshgQjg/DECEYMJCUSTHaxuVpOnQ3HRDo3LSjQ7HAAAAGDQYQQigAuRQBVmDCJRZgcw2O3omr48ZXiKohzkcwEAAIBQ+K+Sw3LY7fqHacMVHdXzuftY1wjE4YxABNAPVGHGYEIC0WQ7jvgTiJfnp5gbCAAAADBAHa5162ev7pEk/ctrezQ8JVZpCdEam5WoWz+Xq02ltZIYgQigf5jCjMGEBKLJukcgTs2lgAoAAAAQCruPNwS+bu/w6VCtW4dq3dp6+LSe2VIR2DcsJc6M8ABEqHiXQ5LU6u1Up8+Qw24zOSIgdEggmqi+pV1lNW5J0lQKqAAAAAAhsfdkoyTp1um5WnbDaB093aLqRo/+svO4PjxWL5ukz41I1ejMBHMDBRBRuqswS5K7vUNJMU4TowFCiwSiiXYerZckjUiLU1qCy9xgAAAAgAFq7wl/AvHS4cnKTY1Tbqp/pOHNU4eZGRaACOeKsivKblOHz1BzGwlEDGz9rtqxceNG3XTTTcrJyZHNZtMrr7zSY79hGLr//vs1dOhQxcbGas6cOTp48GCPY+rq6nTHHXcoKSlJKSkpWrJkiZqbmy/qjUSind3rH+YxfRkAAAAIBW+nL7DG4cScJJOjATCQ2Gw2JXZVYn5553F5OiimgoGr3wlEt9utKVOmaNWqVWfc/8gjj+jxxx/X6tWrtWXLFsXHx2v+/Plqa2sLHHPHHXdoz549Ki4u1uuvv66NGzfqnnvuufB3EaF2VNRLkqbmk0AEAAAAgm3LoVO6/F+L1eEzZLNJ47MTzQ4JwADz5Zl5kqSfv3FA1z7yjk67202OCAiNfk9hXrhwoRYuXHjGfYZh6LHHHtNPf/pTLVq0SJL0pz/9SVlZWXrllVd02223ad++fVq7dq22bt2q6dOnS5J+/etf68Ybb9QvfvEL5eTkXMTbiRydPkO7uqYwX876hwAAAEBQHTnl1lf/8L7aO3ySpNs+l6u4aFZwAhBcP5g3TpmJMXrgf/aosrFNu47V6/pxmWaHBQRdUH+DlpeXq7KyUnPmzAlsS05O1syZM1VSUqLbbrtNJSUlSklJCSQPJWnOnDmy2+3asmWLvvSlL/U6r8fjkcfjCbxubPSvYeL1euX1eoP5FnroPncornGgsknNng7FRTs0MjUmpO/DSkLZpoMZ7Rp8tGnw0aahQbsGX7jalD4DQuNQTbP2nWzSn7cdVXuHT9Pzh+i/lsxUbLTD7NAADEA2m013XjlCGz+u0fr91TpR32p2SEBIBDWBWFlZKUnKysrqsT0rKyuwr7KyUpmZPbPxUVFRSk1NDRzzWStXrtSKFSt6bV+3bp3i4uKCEfpZFRcXB/2c71XZJDk0LMardW+sDfr5rS4UbQraNRRo0+CjTUODdg2+ULdpS0tLSM8PDEYHq5o077GNMoxPtn1n9hiShwBCbtiQWEnS8dMkEDEwRcQY/uXLl6uoqCjwurGxUbm5uZo3b56SkkK3ELLX61VxcbHmzp0rpzO41ZQ2/OUjSSc057JRunHumKCe28pC2aaDGe0afLRp8NGmoUG7Bl+42rR7RgWA4NnwcU2P5OHk4cm6Zky6eQEBGDSGpXQlEBmBiAEqqAnE7OxsSVJVVZWGDh0a2F5VVaXLLrsscEx1dXWP7+vo6FBdXV3g+z/L5XLJ5XL12u50OsPyYSkU19l1rEGSNL0gbVB+4AtX3w02tGvw0abBR5uGBu0afKFuU/oLCL6th+skST9eOF43TclRUkyUbDabyVEBGAy6RyAyhRkDVb+rMJ9NQUGBsrOztX79+sC2xsZGbdmyRYWFhZKkwsJC1dfXa/v27YFj3nrrLfl8Ps2cOTOY4VhWfUu7DtW4JUlT86jADAAAAFwswzC07fBpSdLnRgzRsJRYJcaQqAcQHjkpTGHGwNbvEYjNzc0qLS0NvC4vL9euXbuUmpqqvLw83XvvvXrooYc0ZswYFRQU6Gc/+5lycnJ08803S5ImTJigBQsW6O6779bq1avl9Xq1bNky3XbbbYOmAvPOrurLBenxSo2PNjcYAAAAYAA4VOvWKXe7oqPsmjQs2exwAAwyw7sSiJWNbfJ2+uR0BHW8FmC6ficQt23bpuuvvz7wunttwjvvvFNPP/207rvvPrndbt1zzz2qr6/XVVddpbVr1yomJibwPc8884yWLVum2bNny263a/HixXr88ceD8HYiw84j/r+MTs1LMTcQAAAAIEL5fIbsdpua2ryKi47Sn7cdleQffeiKomgKgPBKT3Ap2mFXe6dPHxyt1/QRqWaHBARVvxOI1113nYxPr0z8GTabTQ8++KAefPDBPo9JTU3Vs88+299LDxg7KuolSZczfRkAAAA4b7uPNeiHL32gprYO1bnblRATpdPudsU6HWrydEiS7rqywOQoAQxGdrtNuamxKqtx6x9Wl+jNoms1OjOh13Hr9lTqob/uU2JMlIYmx2r4kFhNGJqoeROzNYQZirCwiKjCPJB0+gzt6prCTAIRAAAAOLvqpjY9svaA3i+vU0VdS499rd5OSQokD8dlJeqG8ZlhjxEAJOnBRZP0zf/ariZPh557v0I/+8LEXse8+sGJwP/L9pxoDGy//9U9mpiTpIlDk/St60Zp+JC4sMUNnA8SiGF2sLpJzZ4OxUc7NC470exwAAAAAEtb9VapXtp+rMe2GSNSFR1l1/vldbphfKa+Vpiv4/WtunJ0uux2qi4DMMes0el69NbL9E9/2qYn3y3X1wrzlZ8W3+OYpjb/Hzy+fuUIjcpM0NG6Fv39YK32nWzUzop67ayol91m07/ePMmMtwD0iQRimO04Ui9JmpKbIgcPNwAAAECfOn2G1nxUKUkamhwjt6dDP1wwXl+9Il+S1NLeobhoPtIAsI5rx2UoNT5ade52Xfvzd7Tmn6/WxJykwP6mNq8kqXBUmuZfki3JX0W+rKZZT206rGe2VOiU22NK7MDZUBYozHZU+AuoMH0ZAAAA6NvJhlZ94+mtqmnyKCkmSht+eL0+eGBeIHkoieQhAMtxOux66FOjB/edbOyxv7lrBGJizCf//7LZbBqdmahp+f48QfcoRcBKSCCGWSCBmJ9ibiAAAACARe090agv/maTNnxcI0mad0m2oqPsstmYwQPA+m68dKgWXZYjSb1GE3YnB5NinL2+L7FrGwlEWBF/sguj+pZ2HapxS5Km5jICEQAAAPisyoY23fX0+6pp8mhYSqw+P3mollxFZWUAkSW1q6LyKXd7j+3dU5gTXL3TMd3buo8BrIQEYhjtrKiXJI1Mj6c8OwAAAPAZbk+Hlvxxq6oaPRqTmaCXvnWlkmN7j9IBAKtLT3BJkuqaP0kgdvoMudv91eM/PYW5W/c2RiDCikgghlH39OWprH8IAAAABHg7fXpp+zH95q1SHa9vVVp8tP7w9c+RPAQQsbpHINZ9agRis+eTxGDCWRKInz4OsAoSiGHE+ocAAADAJ36/8ZD+Y2OZWts7A6NyspJceuIr05SbGmdydABw4c40hbl7anJ0lF2uKEev7+leA7GlvVMdnT5FOShbAesggRgmnT5Du7qmMFOBGQAAAINdnbtdvyz+WK1ef+IwPcGlb183Sl+emacYZ+8P1gAQSdICCcRPiqh8UkDlzKmYT6+L2OzpUEocS5/BOkgghsnHVU1yt3cqwRWlsVmJZocDAAAAmOqP7x1Wq7dTNpv0xB3TdM3YdMVF8/EEwMAQmMLc3HsKc+IZKjBL3SMT7fJ0+NTURgIR1sJ42DDpnr48JTdZDrvN5GgAAAAA87g9HXr6vcOSpN/cfrkWTMomeQhgQEmL9xdRcbd3qq1rpHX3FOYzFVDp1p1cpJAKrIbf0mGy40i9JKYvAwAAYPD6z78f0kvbj6mprUMNrV6NTI/XgknZZocFAEGXFBulKLtNHT5Dde525aTEBpKCn56q/FmJMVGqbfYEko2AVTACMUx2dhdQIYEIAACAQep3Gw9pf2WTjte3SpK+ee0oZucAGJBsNluvSsyNbd1TmM+eQJSoxAzrYQRiGJx2t+tQrVuSNDUvxdxgAAAAABNUN7apuslfTOAbswo0MSdJt0wdZnJUABA6qfHRqm7yqLS6WZOGJau57exrIPr3+dM0TGGG1ZBADIOdR/2jD0dmxLMIKgAAAAalj040SJLGZCbo/psmmhwNAITepcOStb+yST948QMdr289rynM3fuYwgyrIYEYBqx/CAAAgMFu97FGSf4P1AAwGPz0CxPV4u3UXz88qZ+/cSCwPel8iqgwhRkWQwIxDHaw/iEAAAAGkTW7T+rVXcdVVuNWc1uHclJitKOiXpJ0CQlEAINEcqxTv7l9qq4bm6EH/mePWtr91ZiZwoxIRAIxxDp9hj44Wi9Jujw/xdRYAAAAgFCrbmrTvc/vUnunL7CtsrEt8PWMEalmhAUAprDZbPrH6bm6PH+I/u+6A9pVUa/CUWl9Hp/YNYX5zb1V6vQZujwvRbNGp5816QiEAwnEEDtQ2SR3e6cSXFEak5lodjgAAABAyKzZfVLffmaHJGni0CT9aOF4pcQ69XFVk6qbPJqal6JLhzMCEcDgMyojQb+9Y9o5jxueGidJOljdrIPVzZKkKLtN+WlxykuNU35avHJT/V9Pyx8SqPQMhBoJxBDrnr58WW6KHHabydEAAAAAodHY5tU/P7cz8Prb14/StWMzJElTclNMigoAIsuXpg5ToitKR+padPx0qzaV1upQrVtlNf5/Uk3gWKfDpmn5Q3Tt2EwtmJSt/NQ42ck7IERIIIbYzq61Xi7PSzE1DgAAACCU3j9Upw6fIUm6fUauFlySbXJEABB5nA67Fl46tMe24/WtKq9xq6KuRRV1LTpa16KPq5p0sLpZmw/VafOhOv372v2aMSJVL/zvK2SzkURE8JFADLGdXSMQp+ZTQAUAAAAD16ayWknSHTPz9G9futTkaABg4BiWEqthKbG9tn9c1aT3y+v04vZj+uBovd4/XKf1+6o1Z2KWCVFioCOBGEKn3e06VOuWJF2eSwIRAAAAA5NhGHr3oD+BeOWodJOjAYDBYWxWosZmJeorV+Tr4b/t1+oNZSr68y5dOjxZozISPvmXGa/spBhGJuKikEAMoa2H6yRJozLilRxHxSQAAAAMLLXNHq3ZfVJrdp/UwepmRTvsZ60uCgAIjX+6ukB/3nZUde52bSo9pU2lp3rsHxLn1MyCNC26LKfXFGngfJBADKH3yvw/sDxEAQAAYCBp7/DpH1e/pw+ONfTY/m9fmkRFUAAwQXqCS3+/73odqGpSWXVzV9GVZpXVNOvIqRadbvFq7Z5Krd1Tqd99dZrmsU4t+okEYgi917UOzCymcQAAAITVxo0b9fOf/1zbt2/XyZMn9fLLL+vmm28O7DcMQw888IB+//vfq76+XrNmzdITTzyhMWPGmBd0BHm/vC6QPJw4NEmzJ2Rq1uh0XTGSP5wDgFniXVG6PG+ILs/ruYRae4dPu4836E8lh/XqrhP6P698pGvGZshhUpyITHazAxioqpva9HFVs2w2RiACAACEm9vt1pQpU7Rq1aoz7n/kkUf0+OOPa/Xq1dqyZYvi4+M1f/58tbW1hTnSyPTOgWpJ0s2X5WjNd6/W9+eNI3kIABYVHWXXtPwh+vfFk5UWH62aJo/2nGg0OyxEGEYghkhJ1/TlS3KSlBLHNA4AAIBwWrhwoRYuXHjGfYZh6LHHHtNPf/pTLVq0SJL0pz/9SVlZWXrllVd02223hTPUiNPpM/TahyckSXMnMgUOACJFjNOhcdmJeq/slA7XujU5J8HskBBBGIEYIptKmb4MAABgReXl5aqsrNScOXMC25KTkzVz5kyVlJSYGJl1VTa06fUPT+jH/+9DXfnwelU1euSw23TVaJ51ASCSFKTHS5LKa90mR4JIwwjEEDAMI1DxiOnLAAAA1lJZWSlJysrK6rE9KysrsO+zPB6PPB5P4HVjo3/ql9frldfrDVGkCpw7lNc4m4q6Fn372V06UNXcY3tKrFP3zR+jOKd5sZnJ7H5B3+gba6JfrCM/NVaSVFbdRL9YVDj7pT/XIIEYAhV1LTpe3yqnw6YZBalmhwMAAICLtHLlSq1YsaLX9nXr1ikuLi7k1y8uLg75NT6rziP9dq9DNW022WQoJ04anWRoQoqhUUkdiq76UGvWfBj2uKzEjH7B+aFvrIl+MV/taZskhz4sr1Rx8XFJ9ItVhaNfWlpazvtYEogh0D36cGruEMVF08QAAABWkp3tX7evqqpKQ4cODWyvqqrSZZdddsbvWb58uYqKigKvGxsblZubq3nz5ikpKSlksXq9XhUXF2vu3LlyOp0hu85nVTW2adFvN+tUW7uGpcTo+btnKDspJmzXtzqz+gXnRt9YE/1iHRNPufW7/ZtU53Vozpzr9eabb9IvFhPOn5fuGRXng+xWCGwq869/eOVopi8DAABYTUFBgbKzs7V+/fpAwrCxsVFbtmzRt771rTN+j8vlksvl6rXd6XSG5UNXuK7T7S+7DuuUu12jMuL1pyUzNSwlNmzXjiTh7hecP/rGmugX843ISFKU3aZWr0+LVm9VquwaM82jCcNiZbPZzA4PnxKOn5f+nJ8EYpD5fEagAvMsFpUGAAAwRXNzs0pLSwOvy8vLtWvXLqWmpiovL0/33nuvHnroIY0ZM0YFBQX62c9+ppycHN18883mBW0RPp+hV3b6p7UtvX40yUMAGECcDruuH5+p4r1VKq1xS7Lrxt+8p/SEaF09JkNT81L05Rl5inJQcxc9kUAMsgNVTapztysu2qEpw1PMDgcAAGBQ2rZtm66//vrA6+7px3feeaeefvpp3XfffXK73brnnntUX1+vq666SmvXrlVMzOCdpnu8vlX3/GmbDlY3q73Dp1inQ/MvyTY7LABAkP3uq9N07HSr9p2o16/+ul376u2qbW7XyzuP6+WdxzUiLV7XjM0wO0xYDAnEINtU6p++PKMgVdFRZOwBAADMcN1118kwjD7322w2Pfjgg3rwwQfDGJW1/ffmI9pzwr8Wkt0m/dPVBYp38XEBAAYam82m3NQ4ZSc61Vrm0+y5c/XhiWZ9+T+3SJIqG9tMjhBWxBNBkL3XPX15FNOXAQAAEBkMw9BrH5yQJP374kt1y+XD5WT6GgAMCi6nQ1eOTteXpg7TyzuPq76l3eyQYEEkEIPI2+nTlkP+BGLhKAqoAAAAwNo6On3qNAy9vb9Gx063Kj7aoS9OGUbyEAAGoeRYf0GN+havyZHAikggBtGHx+rlbu/UkDinJg5NMjscAAAAoE+bSmv1jae3ytPhC2y7eeowxUY7TIwKAGCWlLiuBGIrCUT0xp8Wg2hT6SejD+12yp8DAADAmjo6fXror/t6JA9vuXyY7r9poolRAQDMlNI1ArGBEYg4A0YgBlF3AZUrWf8QAAAAFnKyoVW/31iuvScbVNPkUVmNW5IUH+3QuqJrlRLrpGAKAAxyQ+KjJUmnWQMRZ8BTQpC0tndqZ0W9JGnWaBKIAAAAsIZDNc368u+3nLGq5tIbRmtYSqwJUQEArIY1EHE2JBCDZOvhOrV3+pSTHKMRaXFmhwMAAACovqVd33h6qyob21SQHq9vXzdKQ5NjNTIjXvGuqMCHRQAAUuL8IxAbWAMRZxD0NRD/5V/+RTabrce/8ePHB/a3tbVp6dKlSktLU0JCghYvXqyqqqpghxF275X51z+8cnS6bDbWPwQAAIC5th2u05xfbtDhUy0alhKrF79ZqH+cnqurxqQrJyWW5CEAoIeUwAhEpjCjt5AUUbnkkkt08uTJwL933303sO973/ueXnvtNb344ovasGGDTpw4oVtuuSUUYYTVe2X+9Q9njU4zORIAAABAeuiv+1Tb3K6C9Hg9+fXpSk9wmR0SAMDCuqswu9s71f6pIluAFKIpzFFRUcrOzu61vaGhQU8++aSeffZZ3XDDDZKkp556ShMmTNDmzZt1xRVXhCKckGto8Wr38QZJFFABAACA+Q5WNWnX0XpF2W368/8uVEYiyUMAwNklxThls0mGIdW3tiszMcbskGAhIUkgHjx4UDk5OYqJiVFhYaFWrlypvLw8bd++XV6vV3PmzAkcO378eOXl5amkpKTPBKLH45HH4wm8bmxslCR5vV55vaGbm9997nNd492DVTIMaWR6vFJjHSGNKdKdb5uif2jX4KNNg482DQ3aNfjC1ab0GULpmS0VkqTrx2eSPAQAnBe73abkWKfqW7xqaPGSQEQPQU8gzpw5U08//bTGjRunkydPasWKFbr66qv10UcfqbKyUtHR0UpJSenxPVlZWaqsrOzznCtXrtSKFSt6bV+3bp3i4kJfsKS4uPis+186ZJdk1zBHk9asWRPyeAaCc7UpLgztGny0afDRpqFBuwZfqNu0paUlpOfH4FVa3axnthyRJH31inyTowEARJKUrgTiaSox4zOCnkBcuHBh4OvJkydr5syZys/P15///GfFxsZe0DmXL1+uoqKiwOvGxkbl5uZq3rx5SkpKuuiY++L1elVcXKy5c+fK6ex7kelf/WqTJLduu2Gq5k3MClk8A8H5tin6h3YNPto0+GjT0KBdgy9cbdo9owIIhvqWdq3bU6V3S2v15r4qeTsNXT8uQ9eMzTA7NABABEmOi5ZOteh//UeJFl2Wo9kTsnTtmAwlx/GcOdiFZArzp6WkpGjs2LEqLS3V3Llz1d7ervr6+h6jEKuqqs64ZmI3l8sll6v31Aun0xmWD0tnu05lQ5sO1bplt0lXjcniw9t5ClffDTa0a/DRpsFHm4YG7Rp8oW5T+gsXq7S6WW/sqdTuYw3aeLBGLe2dgX2XDkvWQ1+61MToAACR6KbJQ/XR8QZ1+gy9uuuEXt11QpKUnRSj/LQ45abGKS0hWqMyEjQ+O1FjMhMVG+0wOWqEQ8gTiM3NzSorK9NXv/pVTZs2TU6nU+vXr9fixYslSQcOHFBFRYUKCwtDHUpIdFdfnjQsmYw8AAAAQupQTbNe3nlc2w6f1ubyUzKMT/aNy0rUvEuydM3YDE3PHyKbzWZeoACAiPRPV4/UVwvztftYg97cV631+6p0sLpZlY1tqmxs05byul7fMyTOqZW3XKoFk4aaEDHCJegJxB/84Ae66aablJ+frxMnTuiBBx6Qw+HQ7bffruTkZC1ZskRFRUVKTU1VUlKSvvOd76iwsDBiKzBvKj0lierLAAAACK09Jxp02+82q6mtI7Dt+nEZunJUuqbmpWgaSUMAQBC4ohyaPiJV00ek6scLx+u0u12HT7lVUdeio3Utqm1u18dVTTpQ2aRT7nadbvHqD5sOk0Ac4IKeQDx27Jhuv/12nTp1ShkZGbrqqqu0efNmZWT411959NFHZbfbtXjxYnk8Hs2fP1+//e1vgx1GWBiGoZKuEYizRqeZHA0AAAAGkjZvp17deVx/Lbfrj79/X7uO1stnSJOHJ+u2z+XpipGpGpmRYHaYAIABbkh8tIbER2tq3pBe+3YdrdfNqzZpZ8VpuT0dineFfKIrTBL0nn3++efPuj8mJkarVq3SqlWrgn3psDt8qkUnGtoU7bBren6q2eEAAABgALHZpJ++ulfeTrukeknSNWMz9OvbprJ0DgDAEqYMT9bwIbE6drpV75fX6frxmWaHhBAhNXwRNpX6Rx9OzUth0VAAAAAElSvKoVum5qjq+FF94crJmjEyQ3lpcWaHBQBAgM1m09Vj0vXc+0f172v3a9fRen1uRKquGJmqKIfd7PAQRCQQL8J7genLrH8IAACA4Hto0SVas+aIbrwsh8rdAABLumNmvl7ddUL7K5u0v7JJkpQWH62Hbp6khZeyLuJAQTr4Avl8hkrK/AVUWP8QAAAAAAAMRpOGJeut71+ne+eM0S1Th2lInFOn3O267/99qNPudrPDQ5AwAvEC7T3ZqNMtXsVHOzR5eIrZ4QAAAAAAAJgiOzlG984ZK0nydvr0xd9s0r6TjVq0apMmDE3U1wpHMHszwpFAvEDd05dnjkyTk3n9AAAAAAAAcjrsuv8LE3XX0++roq5FFXUtemt/tb47e4xGZSQoJyVWOSmxSk+Ils1mMztcnCcSiBdoU6l/+vKVo5i+DAAAAAAA0K1wVJo2/vB67T3ZqGe3VGjd3ir9Yt3HPY6JjrJrWEqsclJilJPsTyrmp8WpcFSahibHmhQ5+kIC8QK0d/j0fnmdJAqoAAAAAAAAfFZmUowyk2J05ah0/WFTuT463qAT9a06Xt+q6iaP2jt8Kq91q7zW3eP7UuKc2rx8tmKcDpMix5mQQLwAHxyrV6u3U2nx0RqXlWh2OAAAAAAAAJYUHWXXN68d1WNbe4dPVY1tOl7fqhNd/47Xt+q594+qvsWrPScaNC0/1aSIcSYkEC/AplL/+odXjEqT3c58fQAAAAAAgPMVHWVXbmqcclPjemyvaWrXm/uqtLOingSixVD94wK817X+4axRTF8GAAAAAAAIhsvzUyRJOypOmxsIeiGB2E8t7R3aedR/I88aTQEVAAAAAACAYLg8b4gkac3uSt3/6kf687ajqnO3mxwVJKYw99v75XXydhoalhKrvM8MtQUAAAAAAMCFmTw8WbFOh1q9nfpTyRFJUqzToSVXFWj6iCEqHJUmVxTFVcxAArGf3ivrmr48Ok02G+sfAgAAAAAABENcdJSevXumth85rZomjzZ8XKP9lU36zdulkiRXlF2jMhI0KjNBeamxyh3iX0exID1eOSmxJkc/sJFA7KfuAiqzRrP+IQAAAAAAQDBNzRuiqV1TmX+0YLz+vO2oNh6s0bbDp1Xd5NHek43ae7Kx1/eNz07UxJwkjcpI0Ii0eOWnxSk/LU6JMc5wv4UBiQRiP5x2twdu0sJRrH8IAAAAAAAQKna7TbfNyNNtM/Lk8xmqqGvRwepmldc262hdq46ebtHRuhYdPtWi/ZVN2l/Z1OscCa4oZSfHKDsppsd/hybHKKvr69S4aNntzDI9GxKI/VBy6JQMQxqblaDMxBizwwEAAAAAABgU7HabRqTHa0R6vKSsHvtONXv0fnmdymqaVVbj1pFTbh051aJT7nY1ezpUWt2s0urmPs/tirJrxRcv0W0z8kL8LiIXCcR+eK/MP335ylFMXwYAAAAAALCCtASXFl46tNf2Zk+HKhvaVNXYppOB/7aqssGjykb/f2ubPfJ0+PTX3SdJIJ4FCcR+eK/UX0DlSqYvAwAAAAAAWFqCK0qjMxM0OjOhz2P++uFJLX12h5raOsIYWeSxmx1ApDjZ0KpDtW7ZbdLMkSQQAQAAAAAAIt2QeH+RlaY2r8mRWBsJxPO0qWv04aXDU5QcSwUfAAAAAACASJfUVaW52cMIxLMhgXie3iv1r384i+nLAAAAAAAAA0KCy7+6H1OYz44E4nkwDEObugqozBpNARUAAAAAAICBIDHGn0Bsae9Up88wORrrIoF4Hg7Vtqiq0aPoKLum5Q8xOxwAAAAAAAAEQULMJ/WFmxmF2CcSiOeh5JB//cPp+UMU43SYHA0AAAAAAACCwRXlUHSUPz3W5KGQSl9IIJ6H98rqJDF9GQAAAAAAYKBJZB3EcyKBeA4+Q3r/sD+BWEgBFQAAAAAAgAGlex1EKjH3jQTiORx3Sw2tHUp0RWnysGSzwwEAAAAAAEAQda+D2NTGFOa+kEA8h48bbJKkmSNTFeWguQAAAAAAAAaSRJdTElOYz4aM2Dl0JxCvHMX6hwAAAAAAAAPNJyMQSSD2hQTiWXg6fCpr8icQKaACAAAAAAAw8LAG4rmRQDyLXUfr5fXZlJ4QrbFZCWaHAwAAAAAAgCD7pAozayD2hQTiWZQc8ldfvqIgVTabzeRoAAAAAAAAEGyJMf41EJuZwtwnEohn0Z1AvHJUqsmRAAAAAAAAIBRYA/HcoswOwKqaPR368FiDJOmKkSQQAQAAAAAABqLuNRDf3FelW/+jRA2tXnX4DEXZbYpy2BRlt8vZ9V//a5uiHJ/a1n2cwy5n175e39u9zW6Tw2GXTZLNJtlkk90mOR12RUfZZZdPe07blFx2SiMzkpSXFmdu43QhgdiHreV16vAZSnMZyh1ijc4CAABAcK1atUo///nPVVlZqSlTpujXv/61ZsyYYXZYAAAgjMZnJ8lmkxrbOrSlvM7scCQ59Lv92/Xt60bpvgXjzQ5GEgnEPvkMQ5fkJCq5o8HsUAAAABACL7zwgoqKirR69WrNnDlTjz32mObPn68DBw4oMzPT7PAAAECYTMsfoo0/vF5HTrWorqVdybFOuaLs6ug05PX51NFpqKPTJ6/PUKfPJ2+n4d8W+NqnDt+Zt3k7fYHzdH7qGMOQjK7r+3yGvD5D3g6fPB2dqjl1WvEJicpKijG1XT6NBGIfZk/I0jWjU/X6X9eYHQoAAABC4Je//KXuvvtu3XXXXZKk1atX669//av+8Ic/6Mc//rHJ0QEAgHDKTY1Tbqr5M1C9Xq/WrFmjG2+8Uk6n0+xwAkggnoOd4ssAAAADTnt7u7Zv367ly5cHttntds2ZM0clJSW9jvd4PPJ4PIHXjY2NkvwP+V6vN2Rxdp87lNdA/9Ev1kXfWBP9Yk30izWFs1/6cw0SiAAAABh0amtr1dnZqaysrB7bs7KytH///l7Hr1y5UitWrOi1fd26dYqLC/1oheLi4pBfA/1Hv1gXfWNN9Is10S/WFI5+aWlpOe9jSSACAAAA57B8+XIVFRUFXjc2Nio3N1fz5s1TUlJSyK7r9XpVXFysuXPnWmoa02BHv1gXfWNN9Is10S/WFM5+6Z5RcT5IIAIAAGDQSU9Pl8PhUFVVVY/tVVVVys7O7nW8y+WSy+Xqtd3pdIblQ1e4roP+oV+si76xJvrFmugXawpHv/Tn/PYQxgEAAABYUnR0tKZNm6b169cHtvl8Pq1fv16FhYUmRgYAAGA9jEAEAADAoFRUVKQ777xT06dP14wZM/TYY4/J7XYHqjIDAADAjwQiAAAABqVbb71VNTU1uv/++1VZWanLLrtMa9eu7VVYBQAAYLAzdQrzqlWrNGLECMXExGjmzJl6//33zQwHAAAAg8yyZct05MgReTwebdmyRTNnzjQ7JAAAAMsxLYH4wgsvqKioSA888IB27NihKVOmaP78+aqurjYrJAAAAAAAAACfYVoC8Ze//KXuvvtu3XXXXZo4caJWr16tuLg4/eEPfzArJAAAAAAAAACfYcoaiO3t7dq+fbuWL18e2Ga32zVnzhyVlJT0Ot7j8cjj8QReNzY2SpK8Xq+8Xm/I4uw+dyivMdjQpqFBuwYfbRp8tGlo0K7BF642pc8AAAAQKUxJINbW1qqzs7PXAtVZWVnav39/r+NXrlypFStW9Nq+bt06xcXFhSzObsXFxSG/xmBDm4YG7Rp8tGnw0aahQbsGX6jbtKWlJaTnBwAAAIIlIqowL1++XEVFRYHXjY2Nys3N1bx585SUlBSy63q9XhUXF2vu3LlyOp0hu85gQpuGBu0afLRp8NGmoUG7Bl+42rR7RgUAAABgdaYkENPT0+VwOFRVVdVje1VVlbKzs3sd73K55HK5em13Op1h+bAUrusMJrRpaNCuwUebBh9tGhq0a/CFuk3pLwAAAEQKUxKI0dHRmjZtmtavX6+bb75ZkuTz+bR+/XotW7bsnN9vGIak0P/l3uv1qqWlRY2NjTzkBwltGhq0a/DRpsFHm4YG7Rp84WrT7ueY7ucaRBaeRwc3+sW66Btrol+siX6xpnD2S3+eR02bwlxUVKQ777xT06dP14wZM/TYY4/J7XbrrrvuOuf3NjU1SZJyc3NDHSYAAEBINTU1KTk52eww0E88jwIAgIHifJ5HTUsg3nrrraqpqdH999+vyspKXXbZZVq7dm2vwipnkpOTo6NHjyoxMVE2my1kMXavtXj06NGQrrU4mNCmoUG7Bh9tGny0aWjQrsEXrjY1DENNTU3KyckJ2TUQOjyPDm70i3XRN9ZEv1gT/WJN4eyX/jyPmlpEZdmyZec1Zfmz7Ha7hg8fHoKIziwpKYkfpiCjTUODdg0+2jT4aNPQoF2DLxxtysjDyMXzKCT6xcroG2uiX6yJfrGmcPXL+T6P2kMcBwAAAAAAAIAIRgIRAAAAAAAAQJ9IIJ6Fy+XSAw88IJfLZXYoAwZtGhq0a/DRpsFHm4YG7Rp8tCmshPvRmugX66JvrIl+sSb6xZqs2i8243xqNQMAAAAAAAAYlBiBCAAAAAAAAKBPJBABAAAAAAAA9IkEIgAAAAAAAIA+kUAEAAAAAAAA0CcSiH1YtWqVRowYoZiYGM2cOVPvv/++2SFFtH/5l3+RzWbr8W/8+PFmhxVRNm7cqJtuukk5OTmy2Wx65ZVXeuw3DEP333+/hg4dqtjYWM2ZM0cHDx40J9gIcq52/frXv97r3l2wYIE5wUaIlStX6nOf+5wSExOVmZmpm2++WQcOHOhxTFtbm5YuXaq0tDQlJCRo8eLFqqqqMili6zufNr3uuut63avf/OY3TYrY+p544glNnjxZSUlJSkpKUmFhof72t78F9nOPwip4Jg2vYDxv1dXV6Y477lBSUpJSUlK0ZMkSNTc3h/FdDDzBeraoqKjQ5z//ecXFxSkzM1M//OEP1dHREc63MqAE43cpfRJ6Dz/8sGw2m+69997ANvom/M6VE4mEPiGBeAYvvPCCioqK9MADD2jHjh2aMmWK5s+fr+rqarNDi2iXXHKJTp48Gfj37rvvmh1SRHG73ZoyZYpWrVp1xv2PPPKIHn/8ca1evVpbtmxRfHy85s+fr7a2tjBHGlnO1a6StGDBgh737nPPPRfGCCPPhg0btHTpUm3evFnFxcXyer2aN2+e3G534Jjvfe97eu211/Tiiy9qw4YNOnHihG655RYTo7a282lTSbr77rt73KuPPPKISRFb3/Dhw/Xwww9r+/bt2rZtm2644QYtWrRIe/bskcQ9CmvgmTT8gvG8dccdd2jPnj0qLi7W66+/ro0bN+qee+4J11sYkILxbNHZ2anPf/7zam9v13vvvac//vGPevrpp3X//feb8ZYGhIv9XUqfhN7WrVv1H//xH5o8eXKP7fSNOc6WE4mIPjHQy4wZM4ylS5cGXnd2dho5OTnGypUrTYwqsj3wwAPGlClTzA5jwJBkvPzyy4HXPp/PyM7ONn7+858HttXX1xsul8t47rnnTIgwMn22XQ3DMO68805j0aJFpsQzUFRXVxuSjA0bNhiG4b83nU6n8eKLLwaO2bdvnyHJKCkpMSvMiPLZNjUMw7j22muN7373u+YFNQAMGTLE+M///E/uUVgGz6TmupDnrb179xqSjK1btwaO+dvf/mbYbDbj+PHjYYt9oLuQZ4s1a9YYdrvdqKysDBzzxBNPGElJSYbH4wnvGxjA+vO7lD4JraamJmPMmDFGcXFxj+dE+sYcZ8uJREqfMALxM9rb27V9+3bNmTMnsM1ut2vOnDkqKSkxMbLId/DgQeXk5GjkyJG64447VFFRYXZIA0Z5ebkqKyt73LfJycmaOXMm920QvPPOO8rMzNS4ceP0rW99S6dOnTI7pIjS0NAgSUpNTZUkbd++XV6vt8f9On78eOXl5XG/nqfPtmm3Z555Runp6Zo0aZKWL1+ulpYWM8KLOJ2dnXr++efldrtVWFjIPQpL4JnUes7neaukpEQpKSmaPn164Jg5c+bIbrdry5YtYY95oLqQZ4uSkhJdeumlysrKChwzf/58NTY2BkbM4cJdyO9S+iS0li5dqs9//vM9+kDi58VMfeVEIqVPosJylQhSW1urzs7OHp0iSVlZWdq/f79JUUW+mTNn6umnn9a4ceN08uRJrVixQldffbU++ugjJSYmmh1exKusrJSkM9633ftwYRYsWKBbbrlFBQUFKisr009+8hMtXLhQJSUlcjgcZodneT6fT/fee69mzZqlSZMmSfLfr9HR0UpJSelxLPfr+TlTm0rSl7/8ZeXn5ysnJ0cffvihfvSjH+nAgQP6y1/+YmK01rZ7924VFhaqra1NCQkJevnllzVx4kTt2rWLexSm45nUes7neauyslKZmZk99kdFRSk1NZX/fwTJhT5bVFZWnrHvuvfhwlzM71L6JHSef/557dixQ1u3bu21j58Xc5wtJxIpfUICEWGxcOHCwNeTJ0/WzJkzlZ+frz//+c9asmSJiZEBZ3fbbbcFvr700ks1efJkjRo1Su+8845mz55tYmSRYenSpfroo49Y8zSI+mrTT6+vdemll2ro0KGaPXu2ysrKNGrUqHCHGRHGjRunXbt2qaGhQS+99JLuvPNObdiwweywAABnwbOFtfC71HqOHj2q7373uyouLlZMTIzZ4aDL2XIisbGxJkZ2/pjC/Bnp6elyOBy9qt1UVVUpOzvbpKgGnpSUFI0dO1alpaVmhzIgdN+b3LehN3LkSKWnp3Pvnodly5bp9ddf19tvv63hw4cHtmdnZ6u9vV319fU9jud+Pbe+2vRMZs6cKUncq2cRHR2t0aNHa9q0aVq5cqWmTJmiX/3qV9yjsASeSa3nfJ63srOzexW56ejoUF1dHf0WBBfzbJGdnX3GvuvehwtzMb9L6ZPQ2L59u6qrq3X55ZcrKipKUVFR2rBhgx5//HFFRUUpKyuLvrGAT+dEIuXnhQTiZ0RHR2vatGlav359YJvP59P69etVWFhoYmQDS3Nzs8rKyjR06FCzQxkQCgoKlJ2d3eO+bWxs1JYtW7hvg+zYsWM6deoU9+5ZGIahZcuW6eWXX9Zbb72lgoKCHvunTZsmp9PZ4349cOCAKioquF/7cK42PZNdu3ZJEvdqP/h8Pnk8Hu5RWALPpNZzPs9bhYWFqq+v1/bt2wPHvPXWW/L5fIE/7KD/gvFsUVhYqN27d/dI8BYXFyspKUkTJ04MzxsZBPrzu5Q+CY3Zs2dr9+7d2rVrV+Df9OnTdccddwS+pm/M9+mcSMT8vISlVEuEef755w2Xy2U8/fTTxt69e4177rnHSElJ6VHtBv3z/e9/33jnnXeM8vJyY9OmTcacOXOM9PR0o7q62uzQIkZTU5Oxc+dOY+fOnYYk45e//KWxc+dO48iRI4ZhGMbDDz9spKSkGK+++qrx4YcfGosWLTIKCgqM1tZWkyO3trO1a1NTk/GDH/zAKCkpMcrLy40333zTuPzyy40xY8YYbW1tZoduWd/61reM5ORk45133jFOnjwZ+NfS0hI45pvf/KaRl5dnvPXWW8a2bduMwsJCo7Cw0MSore1cbVpaWmo8+OCDxrZt24zy8nLj1VdfNUaOHGlcc801JkduXT/+8Y+NDRs2GOXl5caHH35o/PjHPzZsNpuxbt06wzC4R2ENPJOGXzCetxYsWGBMnTrV2LJli/Huu+8aY8aMMW6//Xaz3tKAEIxni46ODmPSpEnGvHnzjF27dhlr1641MjIyjOXLl5vxlgaEi/1dSp+Ez6erMBsGfWOGc+VEIqFPSCD24de//rWRl5dnREdHGzNmzDA2b95sdkgR7dZbbzWGDh1qREdHG8OGDTNuvfVWo7S01OywIsrbb79tSOr178477zQMwzB8Pp/xs5/9zMjKyjJcLpcxe/Zs48CBA+YGHQHO1q4tLS3GvHnzjIyMDMPpdBr5+fnG3XffzQe3czhTe0oynnrqqcAxra2txre//W1jyJAhRlxcnPGlL33JOHnypHlBW9y52rSiosK45pprjNTUVMPlchmjR482fvjDHxoNDQ3mBm5h3/jGN4z8/HwjOjrayMjIMGbPnh34wGMY3KOwDp5JwysYz1unTp0ybr/9diMhIcFISkoy7rrrLqOpqcmEdzNwBOvZ4vDhw8bChQuN2NhYIz093fj+979veL3eML+bgSMYv0vpk/D4bAKRvgm/c+VEIqFPbIZhGKEd4wgAAAAAAAAgUrEGIgAAAAAAAIA+kUAEAAAAAAAA0CcSiAAAAAAAAAD6RAIRAAAAAAAAQJ9IIAIAAAAAAADoEwlEAAAAAAAAAH0igQgAAAAAAACgTyQQAQAAAAAAAPSJBCIAAAAAAACAPpFABAAAAAAAANAnEogAAAAAAAAA+kQCEQAAAAAAAECf/n9oYiZ/ZU/JMgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 30001/30001 [02:42<00:00, 185.14it/s]\n"
     ]
    }
   ],
   "source": [
    "train_agent(env, agent, target_network, optimizer, td_loss_fn=td_loss_dqn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score: 310.8\n",
      "Well done\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(env_name),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score:', final_score)\n",
    "print('Well done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Record and Play a video of trained agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper function to record videos\n",
    "def record_video(env_id, video_folder, video_length, agent):\n",
    "\n",
    "    vec_env = DummyVecEnv([lambda: gym.make(env_id, render_mode=\"rgb_array\")])\n",
    "    # Record the video starting at the first step\n",
    "    vec_env = VecVideoRecorder(vec_env, video_folder,\n",
    "                           record_video_trigger=lambda x: x == 0, video_length=video_length,\n",
    "                           name_prefix=f\"{type(agent).__name__}-{env_id}\")\n",
    "\n",
    "    obs = vec_env.reset()\n",
    "    for _ in range(video_length + 1):\n",
    "        action = agent.get_action(obs).detach().cpu().numpy()\n",
    "        obs, _, _, _ = vec_env.step(action)\n",
    "    # video filename\n",
    "    file_path = \"./\"+video_folder+vec_env.video_recorder.path.split(\"/\")[-1]\n",
    "    # Save the video\n",
    "    vec_env.close()\n",
    "    return file_path\n",
    "\n",
    "def play_video(file_path):\n",
    "    mp4 = open(file_path, 'rb').read()\n",
    "    data_url = \"data:video/mp4;base64,\" + b64encode(mp4).decode()\n",
    "    return HTML(\"\"\"\n",
    "        <video width=400 controls>\n",
    "              <source src=\"%s\" type=\"video/mp4\">\n",
    "        </video>\n",
    "        \"\"\" % data_url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving video to /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_c/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_c/DQNAgent-CartPole-v1-step-0-to-step-500.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_c/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                        \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_c/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=400 controls>\n",
       "              <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\">\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "video_folder = \"logs/7_c/\"\n",
    "video_length = 500\n",
    "\n",
    "video_file = record_video(env_name, video_folder, video_length, agent)\n",
    "\n",
    "play_video(video_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dueling DQN\n",
    "\n",
    "In this approach as discussed in paper, https://arxiv.org/pdf/1511.06581.pdf , we replace the network. Our DQN and DDQN network was predicting Q values for all the actions in a given state. Instead of that, we will now predict two separate values, one for V(s), a scalar value and A(s,a) - advantage of a given action over V(s). Using these two, Q(s,a) is computed as below:\n",
    "\n",
    "$$ Q(s,a) = V(s) + [A(s,a) - \\frac{1}{|a|} \\sum_{a} A(s,a)] $$\n",
    "\n",
    "![Dueling DQN](./images/dueling_network.png \"Dueling DQN\")\n",
    "\n",
    "Training can be performed using either vanilla DQN or using DDQN approach. For demonstration purposes we will stick to vanilla DQN approach \n",
    "\n",
    "Code of Dueling DQN and associated code for training is given following cells"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DuelingDQNAgent(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, epsilon=0):\n",
    "\n",
    "        super().__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "        \n",
    "        state_dim = state_shape[0]\n",
    "        # a simple NN with state_dim as input vector (input is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.fc1 = nn.Linear(state_dim, 64)\n",
    "        self.fc2 = nn.Linear(64, 128)\n",
    "        self.fc_value = nn.Linear(128, 32)\n",
    "        self.fc_adv = nn.Linear(128, 32)\n",
    "        self.value = nn.Linear(32, 1)\n",
    "        self.adv = nn.Linear(32, n_actions)\n",
    "                \n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the network to get Q(s,a)\n",
    "        x = F.relu(self.fc1(state_t))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        v = F.relu(self.fc_value(x))\n",
    "        v = self.value(v)\n",
    "        adv = F.relu(self.fc_adv(x))\n",
    "        adv = self.adv(adv)\n",
    "        adv_avg = torch.mean(adv, dim=1, keepdim=True)\n",
    "        qvalues = v + adv - adv_avg\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and output is Qvals as numpy array\n",
    "        states = torch.tensor(states, device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def get_action(self, states):\n",
    "        states = torch.tensor(np.array(states), device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        return best_actions\n",
    "    \n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 3 * 10**4\n",
    "\n",
    "# set exploration epsilon \n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup some frequency for logging and updating target network\n",
    "loss_freq = 50\n",
    "refresh_target_network_freq = 100\n",
    "eval_freq = 1000\n",
    "\n",
    "# to clip the gradients\n",
    "max_grad_norm = 5000\n",
    "\n",
    "#set up random numbers\n",
    "seed=0\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed) \n",
    "\n",
    "#init environment\n",
    "env_name = 'CartPole-v1'\n",
    "env = make_env(env_name)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "\n",
    "#init agent, target network and Optimizer\n",
    "agent = DuelingDQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DuelingDQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())\n",
    "optimizer = torch.optim.Adam(agent.parameters(), lr=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.05000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 30001/30001 [02:47<00:00, 179.08it/s]\n"
     ]
    }
   ],
   "source": [
    "train_agent(env, agent, target_network, optimizer, td_loss_fn=td_loss_dqn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score: 274.3333333333333\n",
      "Well done\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(env_name),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score:', final_score)\n",
    "print('Well done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving video to /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_c/DuelingDQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_c/DuelingDQNAgent-CartPole-v1-step-0-to-step-500.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_c/DuelingDQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                        \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_c/DuelingDQNAgent-CartPole-v1-step-0-to-step-500.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=400 controls>\n",
       "              <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\">\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "video_file = record_video(env_name, video_folder, video_length, agent)\n",
    "\n",
    "play_video(video_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n",
    "In this notebook we saw how to train a DDQN agent with experience replay and target networks. As discussed above, we could also combine DDQN with Dueling type of architecture giving us **Dueling DDQN.**\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
